@transloadit/node 4.1.3

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

@@ -0,0 +1,161 @@
+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: true,
+  discount_factor: 1,
+  discount_pct: 0,
+  bytescount: 1,
+  example_code: {
+    steps: {
+      import: {
+        robot: '/s3/import',
+        path: '${fields.input}',
+        credentials: 'YOUR_AWS_CREDENTIALS',
+        return_file_stubs: true,
+      },
+      vod: {
+        robot: '/video/ondemand',
+        use: 'import',
+        variants: {
+          '480p': {
+            preset: 'hls/480p',
+            ffmpeg_stack: '{{ stacks.ffmpeg.recommended_version }}',
+          },
+          '720p': {
+            preset: 'hls/720p',
+            ffmpeg_stack: '{{ stacks.ffmpeg.recommended_version }}',
+          },
+          '1080p': {
+            preset: 'hls/1080p',
+            ffmpeg_stack: '{{ stacks.ffmpeg.recommended_version }}',
+          },
+        },
+      },
+      serve: {
+        use: 'vod',
+        robot: '/file/serve',
+      },
+    },
+  },
+  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,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'beta',
+}
+
+export const robotVideoOndemandInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/video/ondemand'),
+    variants: z
+      .record(videoEncodeSpecificInstructionsSchema)
+      .describe(
+        'Defines the variants the video player can choose from. The keys are the names of the variant as they will appear in the generated playlists and URLs.',
+      ),
+    enabled_variants: z
+      .union([z.string(), z.array(z.string())])
+      .optional()
+      .describe(
+        'Specifies which variants, defined in the variants parameter, are enabled. Non-enabled variants will not be included in the master playlist.',
+      ),
+    segment_duration: z
+      .number()
+      .optional()
+      .default(6)
+      .describe('The duration of each segment in seconds.'),
+    sign_urls_for: z
+      .number()
+      .optional()
+      .default(0)
+      .describe(
+        'When signing URLs is enabled, the URLs in the generated playlist files will be signed. This parameter specifies the duration (in seconds) that the signed URLs will remain valid.',
+      ),
+    asset: z
+      .string()
+      .optional()
+      .describe(
+        'Controls which file is generated. For example, if the parameter is unset, a master playlist referencing the variants is generated.',
+      ),
+    asset_param_name: z
+      .string()
+      .optional()
+      .default('asset')
+      .describe(
+        'Specifies from which URL parameter the asset parameter value is taken and which URL parameter to use when generating playlist files.',
+      ),
+  })
+  .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.',
+      ),
+  })
+
+export type RobotVideoOndemandInstructions = z.infer<typeof robotVideoOndemandInstructionsSchema>
+export type RobotVideoOndemandInstructionsWithHiddenFields = z.infer<
+  typeof robotVideoOndemandInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotVideoOndemandInstructionsSchema = interpolateRobot(
+  robotVideoOndemandInstructionsSchema,
+)
+export type InterpolatableRobotVideoOndemandInstructions =
+  InterpolatableRobotVideoOndemandInstructionsInput
+
+export type InterpolatableRobotVideoOndemandInstructionsInput = z.input<
+  typeof interpolatableRobotVideoOndemandInstructionsSchema
+>
+
+export const interpolatableRobotVideoOndemandInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotVideoOndemandInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotVideoOndemandInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotVideoOndemandInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotVideoOndemandInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotVideoOndemandInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,159 @@
+import { z } from 'zod'
+
+import { stackVersions } from '../stackVersions.ts'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  color_with_alpha,
+  color_without_alpha,
+  interpolateRobot,
+  positionSchema,
+  robotBase,
+  robotFFmpegVideo,
+  robotUse,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      subtitled: {
+        robot: '/video/subtitle',
+        use: {
+          steps: [
+            {
+              name: ':original',
+              fields: 'input_video',
+              as: 'video',
+            },
+            {
+              name: ':original',
+              fields: 'input_srt',
+              as: 'subtitles',
+            },
+          ],
+        },
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+      },
+    },
+  },
+  example_code_description:
+    'If you have two file input fields in a form — one for a video and another for an SRT or VTT subtitle, named `input_video` and `input_srt` respectively (with the HTML `name` attribute), hereʼs how to embed the subtitles into the video with Transloadit:',
+  minimum_charge: 0,
+  output_factor: 0.6,
+  override_lvl1: 'Video Encoding',
+  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,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotVideoSubtitleInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpegVideo)
+  .extend({
+    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))
+      .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.
+`),
+    border_style: z
+      .enum(['box', 'outline', 'shadow'])
+      .default('outline')
+      .describe(`
+Specifies the style of the subtitle. Use the \`border_color\` parameter to specify the color of the border.
+`),
+    border_color: color_with_alpha.default('40000000').describe(`
+The color for the subtitle border. The first two hex digits specify the alpha value of the color.
+`),
+    // TODO: Make font an enum
+    font: z
+      .string()
+      .default('Arial')
+      .describe(`
+The font family to use. Also includes boldness and style of the font.
+
+[Here](/docs/supported-formats/fonts/) is a list of all supported fonts.
+`),
+    font_color: color_without_alpha.default('FFFFFF').describe(`
+The color of the subtitle text. The first two hex digits specify the alpha value of the color.
+`),
+    font_size: z
+      .number()
+      .int()
+      .min(1)
+      .default(16)
+      .describe(`
+Specifies the size of the text.
+`),
+    position: positionSchema.default('bottom').describe(`
+Specifies the position of the subtitles.
+`),
+    language: z
+      .string()
+      .optional()
+      .nullable()
+      .describe(`
+Specifies the language of the subtitles. Only used if the subtitles are external.
+`),
+    keep_subtitles: z
+      .boolean()
+      .default(false)
+      .describe(`
+Specifies if existing subtitles in the input file should be kept or be replaced by the new subtitle. Only used if the subtitles are external.
+`),
+  })
+  .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 interpolatableRobotVideoSubtitleInstructionsSchema = interpolateRobot(
+  robotVideoSubtitleInstructionsSchema,
+)
+export type InterpolatableRobotVideoSubtitleInstructions =
+  InterpolatableRobotVideoSubtitleInstructionsInput
+
+export type InterpolatableRobotVideoSubtitleInstructionsInput = z.input<
+  typeof interpolatableRobotVideoSubtitleInstructionsSchema
+>
+
+export const interpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotVideoSubtitleInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotVideoSubtitleInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotVideoSubtitleInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,158 @@
+import { z } from 'zod'
+
+import { stackVersions } from '../stackVersions.ts'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  color_with_alpha,
+  interpolateRobot,
+  percentageSchema,
+  resize_strategy,
+  robotBase,
+  robotFFmpeg,
+  robotUse,
+} 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: {
+      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',
+  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,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotVideoThumbsInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpeg)
+  .extend({
+    robot: z.literal('/video/thumbs').describe(`
+> [!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.
+`),
+    count: z
+      .number()
+      .int()
+      .min(1)
+      .max(999)
+      .default(8)
+      .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.
+
+To extract thumbnails for specific timestamps, use the \`offsets\` parameter.
+`),
+    offsets: z
+      .union([z.array(z.number()), z.array(percentageSchema)])
+      .default([])
+      .describe(`
+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.
+`),
+    format: z
+      .enum(['jpeg', 'jpg', 'png'])
+      .default('jpeg')
+      .describe(`
+The format of the extracted thumbnail. Supported values are \`"jpg"\`, \`"jpeg"\` and \`"png"\`. Even if you specify the format to be \`"jpeg"\` the resulting thumbnails will have a \`"jpg"\` file extension.
+`),
+    width: z
+      .number()
+      .int()
+      .min(1)
+      .max(1920)
+      .optional()
+      .describe(`
+The width of the thumbnail, in pixels. Defaults to the original width of the video.
+`),
+    height: z
+      .number()
+      .int()
+      .min(1)
+      .max(1080)
+      .optional()
+      .describe(`
+The height of the thumbnail, in pixels. Defaults to the original height of the video.
+`),
+    resize_strategy: resize_strategy.describe(`
+One of the [available resize strategies](/docs/topics/resize-strategies/).
+`),
+    background: color_with_alpha.default('#00000000').describe(`
+The background color of the resulting thumbnails in the \`"rrggbbaa"\` format (red, green, blue, alpha) when used with the \`"pad"\` resize strategy. The default color is black.
+`),
+    rotate: z
+      .union([z.literal(0), z.literal(90), z.literal(180), z.literal(270), z.literal(360)])
+      .default(0)
+      .describe(`
+Forces the video to be rotated by the specified degree integer. Currently, only multiples of 90 are supported. We automatically correct the orientation of many videos when the orientation is provided by the camera. This option is only useful for videos requiring rotation because it was not detected by the camera.
+`),
+    input_codec: z
+      .string()
+      .optional()
+      .describe(`
+Specifies the input codec to use when decoding the video. This is useful for videos with special codecs that require specific decoders.
+`),
+  })
+  .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
+>

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

@@ -0,0 +1,126 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  interpolateRobot,
+  path,
+  robotBase,
+  robotImport,
+  vimeoBase,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: true,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  example_code: {
+    steps: {
+      imported: {
+        robot: '/vimeo/import',
+        credentials: 'YOUR_VIMEO_CREDENTIALS',
+        path: 'me/videos',
+        rendition: '720p',
+        page_number: 1,
+        files_per_page: 20,
+      },
+    },
+  },
+  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
+  .merge(robotImport)
+  .merge(vimeoBase)
+  .extend({
+    robot: z.literal('/vimeo/import'),
+    path: path.default('me/videos').describe(`
+The Vimeo API path to import from. The most common paths are:
+- \`me/videos\`: Your own videos
+- \`me/likes\`: Videos you've liked
+- \`me/albums/:album_id/videos\`: Videos from a specific album
+- \`me/channels/:channel_id/videos\`: Videos from a specific channel
+- \`me/groups/:group_id/videos\`: Videos from a specific group
+- \`me/portfolios/:portfolio_id/videos\`: Videos from a specific portfolio
+- \`me/watchlater\`: Videos in your watch later queue
+
+You can also use an array of path strings here to import multiple paths in the same <dfn>Robot</dfn>'s <dfn>Step</dfn>.
+`),
+    page_number: z
+      .number()
+      .int()
+      .positive()
+      .default(1)
+      .describe('The page number to import from. Vimeo API uses pagination for large result sets.'),
+    files_per_page: z
+      .number()
+      .int()
+      .positive()
+      .max(100)
+      .default(20)
+      .describe('The number of files to import per page. Maximum is 100 as per Vimeo API limits.'),
+    rendition: z
+      .enum(['240p', '360p', '540p', '720p', '1080p', 'source'])
+      .default('720p')
+      .describe('The quality of the video to import.'),
+  })
+  .strict()
+
+export type RobotVimeoImportInstructions = z.infer<typeof robotVimeoImportInstructionsSchema>
+export type RobotVimeoImportInstructionsInput = z.input<typeof robotVimeoImportInstructionsSchema>
+
+export const interpolatableRobotVimeoImportInstructionsSchema = interpolateRobot(
+  robotVimeoImportInstructionsSchema,
+)
+export type InterpolatableRobotVimeoImportInstructions =
+  InterpolatableRobotVimeoImportInstructionsInput
+
+export type InterpolatableRobotVimeoImportInstructionsInput = z.input<
+  typeof interpolatableRobotVimeoImportInstructionsSchema
+>
+
+export const robotVimeoImportInstructionsWithHiddenFieldsSchema =
+  robotVimeoImportInstructionsSchema.extend({
+    access_token: z
+      .string()
+      .optional()
+      .describe('Legacy authentication field. Use credentials instead.'),
+    return_file_stubs: z
+      .boolean()
+      .optional()
+      .describe(
+        'When true, returns file stubs instead of downloading the actual files. Used for testing.',
+      ),
+  })
+
+export const interpolatableRobotVimeoImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotVimeoImportInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotVimeoImportInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotVimeoImportInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotVimeoImportInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotVimeoImportInstructionsWithHiddenFieldsSchema
+>