@transloadit/node 4.1.3

package/src/alphalib/types/robots/upload-handle.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import { interpolateRobot, robotBase } from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  example_code: {
+    steps: {
+      ':original': {
+        robot: '/upload/handle',
+      },
+      exported: {
+        robot: '/s3/store',
+        use: ':original',
+        credentials: 'YOUR_S3_CREDENTIALS',
+      },
+    },
+  },
+  example_code_description: 'Handle uploads and export the uploaded files to S3:',
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'Handling Uploads',
+  purpose_sentence:
+    'receives uploads that your users throw at you from browser or apps, or that you throw at us programmatically',
+  purpose_verb: 'handle',
+  purpose_word: 'handle uploads',
+  purpose_words: 'Handle uploads',
+  service_slug: 'handling-uploads',
+  slot_count: 0,
+  title: 'Handle uploads',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+  name: 'UploadHandleRobot',
+  priceFactor: 10,
+  queueSlotCount: 0,
+  downloadInputFiles: false,
+  preserveInputFileUrls: true,
+  isAllowedForUrlTransform: false,
+  trackOutputFileSize: false,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotUploadHandleInstructionsSchema = robotBase
+  .extend({
+    robot: z.literal('/upload/handle').describe(`
+Transloadit handles file uploads by default, so specifying this <dfn>Robot</dfn> is optional.
+
+It can still be a good idea to define this <dfn>Robot</dfn>, though. It makes your <dfn>Assembly Instructions</dfn> explicit, and allows you to configure exactly how uploads should be handled. For example, you can extract specific metadata from the uploaded files.
+
+There are **3 important constraints** when using this <dfn>Robot</dfn>:
+
+1. Don’t define a \`use\` parameter, unlike with other <dfn>Robots</dfn>.
+2. Use it only once in a single set of <dfn>Assembly Instructions</dfn>.
+3. Name the Step as \`:original\`.
+`),
+  })
+  .strict()
+
+export const robotUploadHandleInstructionsWithHiddenFieldsSchema =
+  robotUploadHandleInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotUploadHandleInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotUploadHandleInstructions = z.infer<typeof robotUploadHandleInstructionsSchema>
+export type RobotUploadHandleInstructionsWithHiddenFields = z.infer<
+  typeof robotUploadHandleInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotUploadHandleInstructionsSchema = interpolateRobot(
+  robotUploadHandleInstructionsSchema,
+)
+export type InterpolatableRobotUploadHandleInstructions =
+  InterpolatableRobotUploadHandleInstructionsInput
+
+export type InterpolatableRobotUploadHandleInstructionsInput = z.input<
+  typeof interpolatableRobotUploadHandleInstructionsSchema
+>
+
+export const interpolatableRobotUploadHandleInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotUploadHandleInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotUploadHandleInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotUploadHandleInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotUploadHandleInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotUploadHandleInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,179 @@
+import { z } from 'zod'
+
+import { stackVersions } from '../stackVersions.ts'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  interpolateRobot,
+  robotBase,
+  robotFFmpegVideo,
+  robotUse,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: Number.POSITIVE_INFINITY,
+  discount_factor: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      ':original': {
+        robot: '/upload/handle',
+      },
+      encoded_480p: {
+        robot: '/video/encode',
+        use: ':original',
+        preset: 'hls/480p',
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+      },
+      encoded_720p: {
+        robot: '/video/encode',
+        use: ':original',
+        preset: 'hls/720p',
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+      },
+      encoded_1080p: {
+        robot: '/video/encode',
+        use: ':original',
+        preset: 'hls/1080p',
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+      },
+      hls_bundled: {
+        robot: '/video/adaptive',
+        use: {
+          steps: ['encoded_480p', 'encoded_720p', 'encoded_1080p'],
+          bundle_steps: true,
+        },
+        technique: 'hls',
+        playlist_name: 'my_playlist.m3u8',
+      },
+    },
+  },
+  example_code_description:
+    'Implementing HTTP Live Streaming: encode the uploaded video into three versions, then cut them into several segments and generate playlist files containing all the segments:',
+  minimum_charge: 0,
+  output_factor: 1.2,
+  override_lvl1: 'Video Encoding',
+  purpose_sentence:
+    'encodes videos into HTTP Live Streaming (HLS) and MPEG-Dash supported formats and generates the necessary manifest and playlist files',
+  purpose_verb: 'convert',
+  purpose_word: 'make adaptive',
+  purpose_words: 'Convert videos to HLS and MPEG-Dash',
+  service_slug: 'video-encoding',
+  slot_count: 60,
+  title: 'Convert videos to HLS and MPEG-Dash',
+  typical_file_size_mb: 80,
+  typical_file_type: 'video',
+  name: 'VideoAdaptiveRobot',
+  priceFactor: 1,
+  queueSlotCount: 60,
+  isAllowedForUrlTransform: false,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotVideoAdaptiveInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpegVideo)
+  .extend({
+    robot: z.literal('/video/adaptive').describe(`
+This <dfn>Robot</dfn> accepts all types of video files and audio files. Do not forget to use <dfn>Step</dfn> bundling in your \`use\` parameter to make the <dfn>Robot</dfn> work on several input files at once.
+
+This <dfn>Robot</dfn> is normally used in combination with [🤖/video/encode](/docs/robots/video-encode/). We have implemented video and audio encoding presets specifically for MPEG-Dash and HTTP Live Streaming support. These presets are prefixed with \`"dash/"\` and \`"hls/"\`. [View a HTTP Live Streaming demo here](/demos/video-encoding/implement-http-live-streaming/).
+
+### Required CORS settings for MPEG-Dash and HTTP Live Streaming
+
+Playing back MPEG-Dash Manifest or HLS playlist files requires a proper CORS setup on the server-side. The file-serving server should be configured to add the following header fields to responses:
+
+\`\`\`
+Access-Control-Allow-Origin: *
+Access-Control-Allow-Methods: GET
+Access-Control-Allow-Headers: *
+\`\`\`
+
+If the files are stored in an Amazon S3 Bucket, you can use the following [CORS definition](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ManageCorsUsing.html) to ensure the CORS header fields are set correctly:
+
+\`\`\`json
+[
+  {
+    "AllowedHeaders": ["*"],
+    "AllowedMethods": ["GET"],
+    "AllowedOrigins": ["*"],
+    "ExposeHeaders": []
+  }
+]
+\`\`\`
+
+To set up CORS for your S3 bucket:
+
+1. Visit <https://s3.console.aws.amazon.com/s3/buckets/>
+1. Click on your bucket
+1. Click "Permissions"
+1. Edit "Cross-origin resource sharing (CORS)"
+
+### Storing Segments and Playlist files
+
+The <dfn>Robot</dfn> gives its result files (segments, initialization segments, MPD manifest files and M3U8 playlist files) the right metadata property \`relative_path\`, so that you can store them easily using one of our storage <dfn>Robots</dfn>.
+
+In the \`path\` parameter of the storage <dfn>Robot</dfn> of your choice, use the <dfn>Assembly Variable</dfn> \`\${file.meta.relative_path}\` to store files in the proper paths to make the playlist files work.
+`),
+    technique: z
+      .enum(['dash', 'hls'])
+      .default('dash')
+      .describe(`
+Determines which streaming technique should be used. Currently supports \`"dash"\` for MPEG-Dash and \`"hls"\` for HTTP Live Streaming.
+`),
+    playlist_name: z
+      .string()
+      .optional()
+      .describe(`
+The filename for the generated manifest/playlist file. The default is \`"playlist.mpd"\` if your \`technique\` is \`"dash"\`, and \`"playlist.m3u8"\` if your \`technique\` is \`"hls"\`.
+`),
+    segment_duration: z
+      .number()
+      .int()
+      .default(10)
+      .describe(`
+The duration for each segment in seconds.
+`),
+    closed_captions: z
+      .boolean()
+      .default(true)
+      .describe(`
+Determines whether you want closed caption support when using the \`"hls"\` technique.
+`),
+  })
+  .strict()
+
+export const robotVideoAdaptiveInstructionsWithHiddenFieldsSchema =
+  robotVideoAdaptiveInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotVideoAdaptiveInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotVideoAdaptiveInstructions = z.infer<typeof robotVideoAdaptiveInstructionsSchema>
+export type RobotVideoAdaptiveInstructionsWithHiddenFields = z.infer<
+  typeof robotVideoAdaptiveInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotVideoAdaptiveInstructionsSchema = interpolateRobot(
+  robotVideoAdaptiveInstructionsSchema,
+)
+export type InterpolatableRobotVideoAdaptiveInstructions =
+  InterpolatableRobotVideoAdaptiveInstructionsInput
+
+export type InterpolatableRobotVideoAdaptiveInstructionsInput = z.input<
+  typeof interpolatableRobotVideoAdaptiveInstructionsSchema
+>
+
+export const interpolatableRobotVideoAdaptiveInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotVideoAdaptiveInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotVideoAdaptiveInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotVideoAdaptiveInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotVideoAdaptiveInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotVideoAdaptiveInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,130 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  interpolateRobot,
+  robotBase,
+  robotFFmpegVideo,
+  robotUse,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: 4,
+  discount_factor: 0.25,
+  discount_pct: 75,
+  example_code: {
+    steps: {
+      concatenated: {
+        robot: '/video/concat',
+        use: {
+          steps: [
+            {
+              name: ':original',
+              fields: 'first_video_file',
+              as: 'video_1',
+            },
+            {
+              name: ':original',
+              fields: 'second_video_file',
+              as: 'video_2',
+            },
+            {
+              name: ':original',
+              fields: 'third_video_file',
+              as: 'video_3',
+            },
+          ],
+        },
+      },
+    },
+  },
+  example_code_description:
+    'If you have a form with 3 file input fields and want to concatenate the uploaded videos in a specific order, instruct Transloadit using the `name` attribute of each input field. Use this attribute as the value for the `fields` key in the JSON, and set `as` to `video_[[index]]`. Transloadit will concatenate the files based on the ascending index order:',
+  minimum_charge: 0,
+  output_factor: 0.6,
+  override_lvl1: 'Video Encoding',
+  purpose_sentence: 'concatenates several videos together',
+  purpose_verb: 'concatenate',
+  purpose_word: 'concatenate',
+  purpose_words: 'Concatenate videos',
+  service_slug: 'video-encoding',
+  slot_count: 60,
+  title: 'Concatenate videos',
+  typical_file_size_mb: 80,
+  typical_file_type: 'video',
+  uses_tools: ['ffmpeg'],
+  name: 'VideoConcatRobot',
+  priceFactor: 4,
+  queueSlotCount: 60,
+  isAllowedForUrlTransform: false,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotVideoConcatInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpegVideo)
+  .extend({
+    robot: z.literal('/video/concat').describe(`
+> [!Note]
+> Input videos may have differing dimensions and streams - the Robot can handle this fine. It will pre-transcode the input videos if necessary before concatenation at no additional cost.
+
+Itʼs possible to concatenate a virtually infinite number of video files using [🤖/video/concat](/docs/robots/video-concat/).
+`),
+    video_fade_seconds: z
+      .number()
+      .default(1)
+      .describe(`
+When used this adds a video fade in and out effect between each section of your concatenated video. The float value is used so if you want a video delay effect of 500 milliseconds between each video section you would select \`0.5\`, however, integer values can also be represented.
+
+This parameter does not add a video fade effect at the beginning or end of your video. If you want to do so, create an additional [🤖/video/encode](/docs/robots/video-encode/) Step and use our \`ffmpeg\` parameter as shown in this [demo](/demos/video-encoding/concatenate-fade-effect/).
+
+Please note this parameter is independent of adding audio fades between sections.
+`),
+    audio_fade_seconds: z
+      .number()
+      .default(1)
+      .describe(`
+When used this adds an audio fade in and out effect between each section of your concatenated video. The float value is used so if you want an audio delay effect of 500 milliseconds between each video section you would select \`0.5\`, however, integer values can also be represented.
+
+This parameter does not add an audio fade effect at the beginning or end of your video. If you want to do so, create an additional [🤖/video/encode](/docs/robots/video-encode/] Step and use our \`ffmpeg\` parameter as shown in this [demo](/demos/audio-encoding/ffmpeg-fade-in-and-out/).
+
+Please note this parameter is independent of adding video fades between sections.
+`),
+  })
+  .strict()
+
+export const robotVideoConcatInstructionsWithHiddenFieldsSchema =
+  robotVideoConcatInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotVideoConcatInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotVideoConcatInstructions = z.infer<typeof robotVideoConcatInstructionsSchema>
+export type RobotVideoConcatInstructionsWithHiddenFields = z.infer<
+  typeof robotVideoConcatInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotVideoConcatInstructionsSchema = interpolateRobot(
+  robotVideoConcatInstructionsSchema,
+)
+export type InterpolatableRobotVideoConcatInstructions =
+  InterpolatableRobotVideoConcatInstructionsInput
+
+export type InterpolatableRobotVideoConcatInstructionsInput = z.input<
+  typeof interpolatableRobotVideoConcatInstructionsSchema
+>
+
+export const interpolatableRobotVideoConcatInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotVideoConcatInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotVideoConcatInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotVideoConcatInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotVideoConcatInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotVideoConcatInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,141 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  interpolateRobot,
+  robotBase,
+  robotUse,
+  videoEncodeSpecificInstructionsSchema,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      hevc_encoded: {
+        robot: '/video/encode',
+        use: ':original',
+        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,
+  isInternal: false,
+  stage: 'ga',
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+}
+
+export const robotVideoEncodeInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(videoEncodeSpecificInstructionsSchema)
+  .extend({
+    robot: z.literal('/video/encode').describe(`
+The /video/encode Robot is a versatile tool for video processing that handles transcoding, resizing, and watermarking. It supports various formats including modern standards like HEVC (H.265), and provides features such as presets for common devices, custom FFmpeg parameters for powerusers, watermark positioning, and more.
+
+## Adding text overlays with FFmpeg
+
+You can add text overlays to videos using FFmpeg's \`drawtext\` filter through this <Definition term="Robot">Robot</Definition>'s \`ffmpeg\` parameter. Here are two examples — one with the default font and one with a custom font family name:
+
+\`\`\`json
+{
+  "steps": {
+    ":original": {
+      "robot": "/upload/handle"
+    },
+    "text_overlay_default": {
+      "use": ":original",
+      "robot": "/video/encode",
+      "preset": "empty",
+      "ffmpeg_stack": "{{stacks.ffmpeg.recommended_version}}",
+      "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"
+      },
+      "result": true
+    },
+    "text_overlay_custom": {
+      "use": ":original",
+      "robot": "/video/encode",
+      "preset": "empty",
+      "ffmpeg_stack": "{{stacks.ffmpeg.recommended_version}}",
+      "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"
+      },
+      "result": true
+    }
+  }
+}
+\`\`\`
+
+**Notes:**
+
+- Use the \`font\` attribute to reference a font by family name with FFmpeg's \`drawtext\`
+- FFmpeg font family names typically do not contain dashes (e.g. \`Times New Roman\`), while
+  ImageMagick uses dashed names (e.g. \`Times-New-Roman\`).
+- 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/).
+`),
+    font_size: z.number().optional(),
+    font_color: z.string().optional(),
+    text_background_color: z.string().optional(),
+  })
+  .strict()
+
+export const robotVideoEncodeInstructionsWithHiddenFieldsSchema =
+  robotVideoEncodeInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotVideoEncodeInstructionsSchema.shape.result])
+      .optional(),
+    chunked_transcoding: z.boolean().optional(),
+    realtime: z.boolean().optional(),
+  })
+
+export type RobotVideoEncodeInstructions = z.infer<typeof robotVideoEncodeInstructionsSchema>
+export type RobotVideoEncodeInstructionsWithHiddenFields = z.infer<
+  typeof robotVideoEncodeInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotVideoEncodeInstructionsSchema = interpolateRobot(
+  robotVideoEncodeInstructionsSchema,
+)
+export type InterpolatableRobotVideoEncodeInstructions =
+  InterpolatableRobotVideoEncodeInstructionsInput
+
+export type InterpolatableRobotVideoEncodeInstructionsInput = z.input<
+  typeof interpolatableRobotVideoEncodeInstructionsSchema
+>
+
+export const interpolatableRobotVideoEncodeInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotVideoEncodeInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotVideoEncodeInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotVideoEncodeInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotVideoEncodeInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotVideoEncodeInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,138 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  color_with_alpha,
+  interpolateRobot,
+  resize_strategy,
+  robotBase,
+  robotFFmpegVideo,
+  robotUse,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  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,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotVideoMergeInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpegVideo)
+  .extend({
+    robot: z.literal('/video/merge'),
+    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.
+`),
+    framerate: z
+      .union([z.number().int().min(1), z.string().regex(/^\d+(?:\/\d+)?$/)])
+      .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.
+`),
+    image_durations: z
+      .array(z.number())
+      .default([])
+      .describe(`
+When merging images to generate a video this allows you to define how long (in seconds) each image will be shown inside of the video. So if you pass 3 images and define \`[2.4, 5.6, 9]\` the first image will be shown for 2.4s, the second image for 5.6s and the last one for 9s. The \`duration\` parameter will automatically be set to the sum of the image_durations, so \`17\` in our example. It can still be overwritten, though, in which case the last image will be shown until the defined duration is reached.
+`),
+    duration: z
+      .number()
+      .default(5)
+      .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\`.
+
+If you set this value to \`null\` (default), then the duration of the input audio file will be used when merging images with an audio file.
+
+When merging audio files and video files, the duration of the longest video or audio file is used by default.
+`),
+    audio_delay: z
+      .number()
+      .default(0)
+      .describe(`
+When merging a video and an audio file, and when merging images and an audio file to generate a video, this is the desired delay in seconds for the audio file to start playing. Imagine you merge a video file without sound and an audio file, but you wish the audio to start playing after 5 seconds and not immediately, then this is the parameter to use.
+`),
+    loop: z
+      .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.`),
+    replace_audio: z
+      .boolean()
+      .default(false)
+      .describe(`
+Determines whether the audio of the video should be replaced with a provided audio file.
+`),
+    vstack: z
+      .boolean()
+      .default(false)
+      .describe(`
+Stacks the input media vertically. All streams need to have the same pixel format and width - so consider using a [/video/encode](/docs/robots/video-encode/) <dfn>Step</dfn> before using this parameter to enforce this.
+`),
+    image_url: z
+      .string()
+      .url()
+      .optional()
+      .describe(`
+The URL of an image to be merged with the audio or video. When this parameter is provided, the robot will download the image from the URL and merge it with the other media.
+`),
+  })
+  .strict()
+
+export const robotVideoMergeInstructionsWithHiddenFieldsSchema =
+  robotVideoMergeInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotVideoMergeInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotVideoMergeInstructions = z.infer<typeof robotVideoMergeInstructionsSchema>
+export type RobotVideoMergeInstructionsWithHiddenFields = z.infer<
+  typeof robotVideoMergeInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotVideoMergeInstructionsSchema = interpolateRobot(
+  robotVideoMergeInstructionsSchema,
+)
+export type InterpolatableRobotVideoMergeInstructions =
+  InterpolatableRobotVideoMergeInstructionsInput
+
+export type InterpolatableRobotVideoMergeInstructionsInput = z.input<
+  typeof interpolatableRobotVideoMergeInstructionsSchema
+>
+
+export const interpolatableRobotVideoMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotVideoMergeInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotVideoMergeInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotVideoMergeInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotVideoMergeInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotVideoMergeInstructionsWithHiddenFieldsSchema
+>