transloadit 4.14.0 → 5.0.0

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

@@ -1,56 +1,39 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import { stackVersions } from '../stackVersions.ts'
 import {
-  interpolateRobot,
+  createProcessingExample,
+  defineRobot,
   robotBase,
   robotFFmpegVideo,
   robotUse,
+  robotVideoEncodingMeta,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      split: {
-        robot: '/video/split',
-        use: ':original',
-        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
-        segments: [
-          { from: 0, to: 30 },
-          { from: 60, to: 90 },
-        ],
-      },
-    },
-  },
+  ...robotVideoEncodingMeta,
+  example_code: createProcessingExample('split', '/video/split', {
+    ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+    segments: [
+      { from: 0, to: 30 },
+      { from: 60, to: 90 },
+    ],
+  }),
   example_code_description:
     'Split a video into two segments, extracting the first 30 seconds and a segment from 1:00 to 1:30:',
-  minimum_charge: 0,
-  output_factor: 0.6,
-  override_lvl1: 'Video Encoding',
   purpose_sentence: 'splits a video into multiple segments based on an array of from/to durations',
   purpose_verb: 'split',
   purpose_word: 'split',
   purpose_words: 'Split video',
-  service_slug: 'video-encoding',
-  slot_count: 60,
   title: 'Split video',
-  typical_file_size_mb: 80,
-  typical_file_type: 'video',
   uses_tools: ['ffmpeg'],
   name: 'VideoSplitRobot',
-  priceFactor: 1,
-  queueSlotCount: 60,
-  isAllowedForUrlTransform: false,
-  trackOutputFileSize: true,
-  applyCommunityPlanMediaTrim: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 const segmentSchema = z
@@ -86,34 +69,22 @@ Times can be specified as numbers (seconds) or as timecode strings (e.g. \`"00:0
   })
   .strict()
 
-export const robotVideoSplitInstructionsWithHiddenFieldsSchema =
-  robotVideoSplitInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotVideoSplitInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotVideoSplitInstructions = z.infer<typeof robotVideoSplitInstructionsSchema>
-export type RobotVideoSplitInstructionsWithHiddenFields = z.infer<
-  typeof robotVideoSplitInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotVideoSplitInstructionsSchema.shape> =
+  defineRobot(meta, robotVideoSplitInstructionsSchema)
 
-export const interpolatableRobotVideoSplitInstructionsSchema = interpolateRobot(
-  robotVideoSplitInstructionsSchema,
-)
-export type InterpolatableRobotVideoSplitInstructions =
-  InterpolatableRobotVideoSplitInstructionsInput
+export const {
+  withHiddenFields: robotVideoSplitInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotVideoSplitInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotVideoSplitInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotVideoSplitInstructionsInput = z.input<
-  typeof interpolatableRobotVideoSplitInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotVideoSplitInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotVideoSplitInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotVideoSplitInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotVideoSplitInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotVideoSplitInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotVideoSplitInstructionsWithHiddenFieldsSchema
->
+export type RobotVideoSplitInstructions = Instructions['output']
+export type RobotVideoSplitInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotVideoSplitInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoSplitInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoSplitInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotVideoSplitInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,22 +1,26 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
+import { zodInputPreservingTransform } from '../../lib/zodInputSemantics.ts'
 import { stackVersions } from '../stackVersions.ts'
 import {
   color_with_alpha,
   color_without_alpha,
-  interpolateRobot,
+  defineRobot,
   positionSchema,
   robotBase,
   robotFFmpegVideo,
   robotUse,
+  robotVideoEncodingMeta,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
+  ...robotVideoEncodingMeta,
   example_code: {
     steps: {
       add_english_subtitles: {
@@ -62,29 +66,14 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description:
-    'If you have file input fields in a form — one for a video and one for each subtitle language (named `input_video`, `input_srt_en`, and `input_srt_de` via the HTML `name` attribute) — hereʼs how to add multiple subtitle streams with language tags to the video. Chain multiple `/video/subtitle` Steps with `keep_subtitles` set to `true` so each new stream is added alongside existing ones:',
-  minimum_charge: 0,
-  output_factor: 0.6,
-  override_lvl1: 'Video Encoding',
+    'If you have file input fields in a form — one for a video and one for each subtitle language (named `input_video`, `input_srt_en`, and `input_srt_de` via the HTML `name` attribute) — here’s how to add multiple subtitle streams with language tags to the video. Chain multiple `/video/subtitle` Steps with `keep_subtitles` set to `true` so each new stream is added alongside existing ones:',
   purpose_sentence: 'adds subtitles and closed captions to videos',
   purpose_verb: 'subtitle',
   purpose_word: 'subtitle',
   purpose_words: 'Add subtitles to videos',
-  service_slug: 'video-encoding',
-  slot_count: 60,
   title: 'Add subtitles to videos',
-  typical_file_size_mb: 80,
-  typical_file_type: 'video',
   uses_tools: ['ffmpeg'],
   name: 'VideoSubtitleRobot',
-  priceFactor: 1,
-  queueSlotCount: 60,
-  isAllowedForUrlTransform: false,
-  trackOutputFileSize: true,
-  applyCommunityPlanMediaTrim: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotVideoSubtitleInstructionsSchema = robotBase
@@ -94,9 +83,9 @@ export const robotVideoSubtitleInstructionsSchema = robotBase
     robot: z.literal('/video/subtitle').describe(`
 This <dfn>Robot</dfn> supports both SRT and VTT subtitle files.
 `),
-    subtitles_type: z
-      .enum(['burned', 'external', 'burn'])
-      .transform((val) => (val === 'burn' ? 'burned' : val))
+    subtitles_type: zodInputPreservingTransform(z.enum(['burned', 'external', 'burn']), (val) =>
+      val === 'burn' ? 'burned' : val,
+    )
       .default('external')
       .describe(`
 Determines if subtitles are added as a separate stream to the video (value \`"external"\`) that then can be switched on and off in your video player, or if they should be burned directly into the video (value \`"burned"\` or \`"burn"\`) so that they become part of the video stream.
@@ -181,34 +170,23 @@ Specifies if existing subtitles in the input file should be kept or be replaced
   })
   .strict()
 
-export const robotVideoSubtitleInstructionsWithHiddenFieldsSchema =
-  robotVideoSubtitleInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotVideoSubtitleInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotVideoSubtitleInstructions = z.infer<typeof robotVideoSubtitleInstructionsSchema>
-export type RobotVideoSubtitleInstructionsWithHiddenFields = z.infer<
-  typeof robotVideoSubtitleInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotVideoSubtitleInstructionsSchema.shape> =
+  defineRobot(meta, robotVideoSubtitleInstructionsSchema)
 
-export const interpolatableRobotVideoSubtitleInstructionsSchema = interpolateRobot(
-  robotVideoSubtitleInstructionsSchema,
-)
-export type InterpolatableRobotVideoSubtitleInstructions =
-  InterpolatableRobotVideoSubtitleInstructionsInput
+export const {
+  withHiddenFields: robotVideoSubtitleInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotVideoSubtitleInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotVideoSubtitleInstructionsInput = z.input<
-  typeof interpolatableRobotVideoSubtitleInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotVideoSubtitleInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotVideoSubtitleInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsSchema
->
+export type RobotVideoSubtitleInstructions = Instructions['output']
+export type RobotVideoSubtitleInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotVideoSubtitleInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoSubtitleInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoSubtitleInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,55 +1,56 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import { stackVersions } from '../stackVersions.ts'
 import {
   color_with_alpha,
-  interpolateRobot,
+  createProcessingExample,
+  defineRobot,
   percentageSchema,
   resize_strategy,
   robotBase,
   robotFFmpeg,
   robotUse,
+  robotVideoEncodingMeta,
 } from './_instructions-primitives.ts'
 
+/** Markup over the AI provider cost for smart thumbnail selection. */
+export const smartThumbnailMarkupPercent = 50
+
+const thumbnailCountSchema = z.number().int().min(1).max(999).default(8)
+const smartMaximumCandidatesSchema = z.number().int().min(2).max(100).default(20)
+const defaultThumbnailCount = thumbnailCountSchema.parse(undefined)
+const defaultSmartMaximumCandidates = smartMaximumCandidatesSchema.parse(undefined)
+
+/** Candidate-pool size shared by smart thumbnail execution and its documented default example. */
+export function getSmartThumbnailCandidateCount(count: number, maximumCandidates: number): number {
+  return Math.max(count, Math.min(maximumCandidates, count * 3))
+}
+
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
-  example_code: {
-    steps: {
-      thumbnailed: {
-        robot: '/video/thumbs',
-        use: ':original',
-        count: 10,
-        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
-      },
-    },
-  },
-  example_code_description: 'Extract 10 thumbnails from each uploaded video:',
-  minimum_charge: 0,
-  output_factor: 0.05,
-  override_lvl1: 'Video Encoding',
+  ...robotVideoEncodingMeta,
+  example_code: createProcessingExample('thumbnailed', '/video/thumbs', {
+    count: 3,
+    ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+    smart: true,
+    smart_max_candidates: 12,
+  }),
+  example_code_description:
+    'Select three visually appealing thumbnails from each uploaded video with AI:',
   purpose_sentence: 'extracts any number of images from videos for use as previews',
   purpose_verb: 'extract',
   purpose_word: 'thumbnail',
   purpose_words: 'Extract thumbnails from videos',
-  service_slug: 'video-encoding',
-  slot_count: 15,
   title: 'Extract thumbnails from videos',
-  typical_file_size_mb: 80,
-  typical_file_type: 'video',
   uses_tools: ['ffmpeg'],
   name: 'VideoThumbsRobot',
   priceFactor: 10,
   queueSlotCount: 15,
-  isAllowedForUrlTransform: false,
-  trackOutputFileSize: true,
-  applyCommunityPlanMediaTrim: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotVideoThumbsInstructionsSchema = robotBase
@@ -57,16 +58,23 @@ export const robotVideoThumbsInstructionsSchema = robotBase
   .merge(robotFFmpeg)
   .extend({
     robot: z.literal('/video/thumbs').describe(`
+Set \`smart: true\` to select strong preview images with AI instead of taking frames only at regular intervals. The Robot scores candidate frames for clarity, brightness, composition, faces, expressions, action, and visual interest, then returns the best \`count\` frames in chronological order. Smart results include \`file.meta.smart_score\` and \`file.meta.smart_reasons\`. If AI scoring is unavailable, the Assembly continues with the candidate frames in fallback order. No AI credentials are required.
+
+## AI pricing
+
+Regular \`/video/thumbs\` processing charges still apply. AI frame analysis is billed separately at the underlying provider cost plus a ${smartThumbnailMarkupPercent}% Transloadit markup. The exact AI charge varies with the number of candidate frames, the internally selected model and provider pricing, and the image payload size.
+
+\`smart_max_candidates\` is the main cost and latency control. The Robot analyzes up to three candidates per requested thumbnail, capped by \`smart_max_candidates\`, but never fewer than \`count\`. With the defaults of \`count: ${defaultThumbnailCount}\` and \`smart_max_candidates: ${defaultSmartMaximumCandidates}\`, it analyzes ${getSmartThumbnailCandidateCount(defaultThumbnailCount, defaultSmartMaximumCandidates)} frames and returns the best ${defaultThumbnailCount}. Lower the candidate limit to reduce AI cost and latency; raise it to give the AI more frames to choose from.
+
 > [!Note]
-> Even though thumbnails are extracted from videos in parallel, we sort the thumbnails before adding them to the Assembly results. So the order in which they appear there reflects the order in which they appear in the video. You can also make sure by checking the <code>thumb_index</code> meta key.
+> Use \`count\` with smart selection. To consistently extract exact timestamps with \`offsets\`, set \`smart: false\`.
+
+> [!Note]
+> Even though thumbnails are extracted from videos in parallel, we sort the thumbnails before adding them to the Assembly results. So the order in which they appear there reflects the order in which they appear in the video. You can also make sure by checking the \`thumb_index\` meta key.
+
+For an upload-to-poster Template, SDK usage, and publication checks, see the [HTML video workflow guide](/guides/html-video-production-checklist/#html-video-production-checklist-section-6). The [video and S3 demo](/demos/file-exporting/store-encoding-and-thumbnails-on-s3/) includes a recorded input and extracted frames.
 `),
-    count: z
-      .number()
-      .int()
-      .min(1)
-      .max(999)
-      .default(8)
-      .describe(`
+    count: thumbnailCountSchema.describe(`
 The number of thumbnails to be extracted. As some videos have incorrect durations, the actual number of thumbnails generated may be less in rare cases. The maximum number of thumbnails we currently allow is 999.
 
 The thumbnails are taken at regular intervals, determined by dividing the video duration by the count. For example, a count of 3 will produce thumbnails at 25%, 50% and 75% through the video.
@@ -80,6 +88,8 @@ To extract thumbnails for specific timestamps, use the \`offsets\` parameter.
 An array of offsets representing seconds of the file duration, such as \`[ 2, 45, 120 ]\`. Millisecond durations of a file can also be used by using decimal place values. For example, an offset from 1250 milliseconds would be represented with \`1.25\`. Offsets can also be percentage values such as \`[ "2%", "50%", "75%" ]\`.
 
 This option cannot be used with the \`count\` parameter, and takes precedence if both are specified. Out-of-range offsets are silently ignored.
+
+When \`smart\` is \`true\`, smart selection ignores \`offsets\` and uses \`count\` to select from its own candidate timestamps. If no smart candidates can be extracted, the Robot falls back to standard extraction, where \`offsets\` takes precedence. Use \`smart: false\` to consistently extract the specified timestamps.
 `),
     format: z
       .enum(['jpeg', 'jpg', 'png'])
@@ -136,52 +146,38 @@ The AI evaluates frames based on:
 - Action and motion (avoiding transition frames)
 - Overall visual interest
 
-Smart thumbnail analysis is billed with a 50% margin over the underlying AI provider cost.
+Regular \`/video/thumbs\` processing charges still apply. AI frame analysis is billed separately at the underlying provider cost plus a ${smartThumbnailMarkupPercent}% Transloadit markup. You do not need to provide AI credentials.
+
+Smart mode generates its own regularly spaced candidate timestamps; use \`smart: false\` with \`offsets\` when you need specified timestamps. Selected smart thumbnails are returned in chronological order, not score order. Inspect \`meta.thumb_offset\`, \`meta.smart_score\`, and \`meta.smart_reasons\` when evaluating the selection.
+
+If AI scoring fails, the Robot selects from the extracted candidates in chronological order and records a fallback reason. If no candidates can be extracted, it attempts standard thumbnail extraction. A completed Assembly does not guarantee a representative or publication-safe poster; check that outputs exist and apply your application’s review policy.
 `),
-    smart_max_candidates: z
-      .number()
-      .int()
-      .min(2)
-      .max(100)
-      .default(20)
-      .describe(`
-The maximum number of candidate frames to extract and analyze when \`smart\` is \`true\`.
+    smart_max_candidates: smartMaximumCandidatesSchema.describe(`
+The maximum size of the candidate pool when \`smart\` is \`true\`. The Robot analyzes up to three candidates per requested thumbnail, capped by this value, but it will never analyze fewer candidates than the requested \`count\`.
 
-A higher number may yield better results but increases processing time and cost. The Robot will extract this many frames evenly distributed across the video, analyze them with AI, and return only the top \`count\` results.
+A higher number may yield better results but increases processing time and AI cost. With the defaults of \`count: ${defaultThumbnailCount}\` and \`smart_max_candidates: ${defaultSmartMaximumCandidates}\`, the Robot analyzes ${getSmartThumbnailCandidateCount(defaultThumbnailCount, defaultSmartMaximumCandidates)} frames and returns the best ${defaultThumbnailCount} in chronological order.
 
 This parameter is only used when \`smart\` is \`true\`.
 `),
   })
   .strict()
 
-export const robotVideoThumbsInstructionsWithHiddenFieldsSchema =
-  robotVideoThumbsInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotVideoThumbsInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotVideoThumbsInstructions = z.infer<typeof robotVideoThumbsInstructionsSchema>
-export type RobotVideoThumbsInstructionsWithHiddenFields = z.infer<
-  typeof robotVideoThumbsInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotVideoThumbsInstructionsSchema = interpolateRobot(
-  robotVideoThumbsInstructionsSchema,
-)
-export type InterpolatableRobotVideoThumbsInstructions =
-  InterpolatableRobotVideoThumbsInstructionsInput
-
-export type InterpolatableRobotVideoThumbsInstructionsInput = z.input<
-  typeof interpolatableRobotVideoThumbsInstructionsSchema
->
-
-export const interpolatableRobotVideoThumbsInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotVideoThumbsInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotVideoThumbsInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotVideoThumbsInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotVideoThumbsInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotVideoThumbsInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotVideoThumbsInstructionsSchema.shape> =
+  defineRobot(meta, robotVideoThumbsInstructionsSchema)
+
+export const {
+  withHiddenFields: robotVideoThumbsInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotVideoThumbsInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotVideoThumbsInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
+
+export type RobotVideoThumbsInstructions = Instructions['output']
+export type RobotVideoThumbsInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotVideoThumbsInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoThumbsInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoThumbsInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotVideoThumbsInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/vimeo-import.ts

@@ -1,4 +1,4 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
@@ -7,13 +7,12 @@ import {
   path,
   robotBase,
   robotImport,
+  robotImportMeta,
   vimeoBase,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
+  ...robotImportMeta,
   example_code: {
     steps: {
       imported: {
@@ -28,27 +27,14 @@ export const meta: RobotMetaInput = {
   },
   example_code_description: 'Import videos from your Vimeo account:',
   has_small_icon: true,
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'File Importing',
   purpose_sentence: 'imports videos from your Vimeo account',
-  purpose_verb: 'import',
   purpose_word: 'Vimeo',
   purpose_words: 'Import videos from Vimeo',
   requires_credentials: true,
-  service_slug: 'file-importing',
-  slot_count: 20,
   title: 'Import videos from Vimeo',
   typical_file_size_mb: 50,
   typical_file_type: 'video',
   name: 'VimeoImportRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 20,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-  stage: 'ga',
 }
 
 export const robotVimeoImportInstructionsSchema = robotBase
@@ -124,3 +110,12 @@ export type InterpolatableRobotVimeoImportInstructionsWithHiddenFields = z.infer
 export type InterpolatableRobotVimeoImportInstructionsWithHiddenFieldsInput = z.input<
   typeof interpolatableRobotVimeoImportInstructionsWithHiddenFieldsSchema
 >
+
+export const robotDefinition: RobotSchemaPair<
+  typeof interpolatableRobotVimeoImportInstructionsSchema,
+  typeof interpolatableRobotVimeoImportInstructionsWithHiddenFieldsSchema
+> = {
+  meta,
+  interpolatable: interpolatableRobotVimeoImportInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotVimeoImportInstructionsWithHiddenFieldsSchema,
+}

package/src/alphalib/types/robots/vimeo-store.ts

@@ -1,47 +1,35 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse, vimeoBase } from './_instructions-primitives.ts'
+import {
+  createProcessingExample,
+  defineRobotWithHiddenFields,
+  robotBase,
+  robotStoreMeta,
+  robotUse,
+  vimeoBase,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 6,
-  discount_factor: 0.15000150001500018,
-  discount_pct: 84.99984999849998,
+  ...robotStoreMeta,
   hideCredentialsWarning: true,
-  example_code: {
-    steps: {
-      exported: {
-        robot: '/vimeo/store',
-        use: ':original',
-        credentials: 'YOUR_VIMEO_CREDENTIALS',
-        title: 'Transloadit: Video Example',
-        description: 'Some nice description',
-      },
-    },
-  },
+  example_code: createProcessingExample('exported', '/vimeo/store', {
+    credentials: 'YOUR_VIMEO_CREDENTIALS',
+    title: 'Transloadit: Video Example',
+    description: 'Some nice description',
+  }),
   example_code_description: 'Export an uploaded video to Vimeo and set its title and description:',
   has_small_icon: true,
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'File Exporting',
   purpose_sentence: 'exports encoding results to Vimeo',
-  purpose_verb: 'export',
   purpose_word: 'Vimeo',
   purpose_words: 'Export files to Vimeo',
-  service_slug: 'file-exporting',
-  slot_count: 10,
   title: 'Export files to Vimeo',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'VimeoStoreRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 10,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotVimeoStoreInstructionsSchema = robotBase
@@ -118,38 +106,31 @@ Deprecated. Please use \`folder_id\` instead. The URI of the folder to which the
   })
   .strict()
 
-export const robotVimeoStoreInstructionsWithHiddenFieldsSchema =
-  robotVimeoStoreInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotVimeoStoreInstructionsSchema.shape.result])
-      .optional(),
-    access_token: z
-      .string()
-      .optional()
-      .describe('Legacy authentication field. Use credentials instead.'),
-  })
+const hiddenFields = {
+  access_token: z
+    .string()
+    .optional()
+    .describe('Legacy authentication field. Use credentials instead.'),
+}
 
-export type RobotVimeoStoreInstructions = z.infer<typeof robotVimeoStoreInstructionsSchema>
-export type RobotVimeoStoreInstructionsWithHiddenFields = z.infer<
-  typeof robotVimeoStoreInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotVimeoStoreInstructionsSchema = interpolateRobot(
-  robotVimeoStoreInstructionsSchema,
-)
-export type InterpolatableRobotVimeoStoreInstructions =
-  InterpolatableRobotVimeoStoreInstructionsInput
-
-export type InterpolatableRobotVimeoStoreInstructionsInput = z.input<
-  typeof interpolatableRobotVimeoStoreInstructionsSchema
->
-
-export const interpolatableRobotVimeoStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotVimeoStoreInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotVimeoStoreInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotVimeoStoreInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotVimeoStoreInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotVimeoStoreInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotVimeoStoreInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotVimeoStoreInstructionsSchema, hiddenFields)
+
+export const {
+  withHiddenFields: robotVimeoStoreInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotVimeoStoreInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotVimeoStoreInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
+
+export type RobotVimeoStoreInstructions = Instructions['output']
+export type RobotVimeoStoreInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotVimeoStoreInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotVimeoStoreInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotVimeoStoreInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotVimeoStoreInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']