transloadit 3.0.2 → 4.0.0-2

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

@@ -0,0 +1,86 @@
+import { z } from 'zod'
+
+import {
+  color_with_alpha,
+  color_without_alpha,
+  robotFFmpegVideo,
+  positionSchema,
+  robotBase,
+  robotUse,
+} from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+import { stackVersions } from '../stackVersions.ts'
+
+export const meta: RobotMeta = {
+  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'],
+}
+
+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.
+`),
+  })
+  .strict()
+export type RobotVideoSubtitleInstructions = z.infer<typeof robotVideoSubtitleInstructionsSchema>

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

@@ -0,0 +1,88 @@
+import { z } from 'zod'
+
+import {
+  color_with_alpha,
+  robotFFmpeg,
+  percentageSchema,
+  resize_strategy,
+  robotBase,
+  robotUse,
+} from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+import { stackVersions } from '../stackVersions.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: false,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  docs_redirect_from: ['/docs/extracting-thumbnails-from-videos/'],
+  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'],
+}
+
+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. [{.alert .alert-note}]
+`),
+    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().int()), 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/transcoding/image-manipulation/image-resize/#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.
+`),
+  })
+  .strict()
+
+export type RobotVideoThumbsInstructions = z.infer<typeof robotVideoThumbsInstructionsSchema>

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

@@ -0,0 +1,84 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 6,
+  discount_factor: 0.15000150001500018,
+  discount_pct: 84.99984999849998,
+  example_code: {
+    steps: {
+      exported: {
+        robot: '/vimeo/store',
+        use: ':original',
+        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',
+}
+
+export const robotVimeoStoreInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/vimeo/store'),
+    credentials: z.string().describe(`
+The authentication Template Credentials used for your Vimeo account. You can generate them on the [Template Credentials page](/c/template-credentials/). You will be redirected to a Vimeo verification page. Accept the presented permissions and you will be good to go.
+`),
+    title: z.string().describe(`
+The title of the video to be displayed on Vimeo.
+`),
+    description: z.string().describe(`
+The description of the video to be displayed on Vimeo.
+`),
+    acl: z
+      .enum(['anybody', 'contacts', 'disable', 'nobody', 'password', 'unlisted', 'users'])
+      .default('anybody').describe(`
+Controls access permissions for the video. Here are the valid values:
+
+- \`"anybody"\` — anyone can access the video.
+- \`"contacts"\` — only those who follow the owner on Vimeo can access the video.
+- \`"disable"\` — the video is embeddable, but it's hidden on Vimeo and can't be played.
+- \`"nobody"\` — no one except the owner can access the video.
+- \`"password"\` — only those with the password can access the video.
+- \`"unlisted"\` — only those with the private link can access the video.
+- \`"users"\` — only Vimeo members can access the video.
+`),
+    password: z.string().optional().describe(`
+The password to access the video if \`acl\` is \`"password"\`.
+`),
+    showcases: z.array(z.string()).default([]).describe(`
+An array of string IDs of showcases that you want to add the video to. The IDs can be found when browsing Vimeo. For example \`https://vimeo.com/manage/showcases/[SHOWCASE_ID]/info\`.
+`),
+    downloadable: z.boolean().default(false).describe(`
+Whether or not the video can be downloaded from the Vimeo website.
+
+Only set this to \`true\` if you have unlocked this feature in your Vimeo accounting by upgrading to their "Pro" plan. If you use it while on their Freemium plan, the Vimeo API will return an \`"Invalid parameter supplied"\` error.
+`),
+    folder_id: z.string().nullable().default(null).describe(`
+The ID of the folder to which the video is uploaded.
+
+When visiting one of your folders, the URL is similar to \`https://vimeo.com/manage/folders/xxxxxxxx\`. The folder_id would be \`"xxxxxxxx"\`.
+`),
+  })
+  .strict()
+
+export type RobotVimeoStoreInstructions = z.infer<typeof robotVimeoStoreInstructionsSchema>
+export type RobotVimeoStoreInstructionsInput = z.input<typeof robotVimeoStoreInstructionsSchema>

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

@@ -0,0 +1,84 @@
+import { z } from 'zod'
+
+import {
+  files_per_page,
+  robotImport,
+  page_number,
+  path,
+  recursive,
+  robotBase,
+  wasabiBase,
+} from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  example_code: {
+    steps: {
+      imported: {
+        robot: '/wasabi/import',
+        credentials: 'YOUR_WASABI_CREDENTIALS',
+        path: 'path/to/files/',
+        recursive: true,
+      },
+    },
+  },
+  example_code_description:
+    'Import files from the `path/to/files` directory and its subdirectories:',
+  has_small_icon: true,
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'File Importing',
+  purpose_sentence: 'imports whole directories of files from your wasabi bucket',
+  purpose_verb: 'import',
+  purpose_word: 'Wasabi',
+  purpose_words: 'Import files from Wasabi',
+  requires_credentials: true,
+  service_slug: 'file-importing',
+  slot_count: 20,
+  title: 'Import files from Wasabi',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+}
+
+export const robotWasabiImportInstructionsSchema = robotBase
+  .merge(robotImport)
+  .merge(wasabiBase)
+  .extend({
+    result: z
+      .boolean()
+      .optional()
+      .describe(`Whether the results of this Step should be present in the Assembly Status JSON`),
+    robot: z.literal('/wasabi/import'),
+    path: path.describe(`
+The path in your bucket to the specific file or directory. If the path points to a file, only this file will be imported. For example: \`images/avatar.jpg\`.
+
+If it points to a directory, indicated by a trailing slash (\`/\`), then all files that are direct descendants of this directory will be imported. For example: \`images/\`.
+
+Directories are **not** imported recursively. If you want to import files from subdirectories and sub-subdirectories, enable the \`recursive\` parameter.
+
+If you want to import all files from the root directory, please use \`/\` as the value here. In this case, make sure all your objects belong to a path. If you have objects in the root of your bucket that aren't prefixed with \`/\`, you'll receive an error: \`A client error (NoSuchKey) occurred when calling the GetObject operation: The specified key does not exist.\`
+
+You can also use an array of path strings here to import multiple paths in the same <dfn>Robot</dfn>'s <dfn>Step</dfn>.
+`),
+    recursive: recursive.describe(`
+Setting this to \`true\` will enable importing files from subfolders and sub-subfolders, etc. of the given path.
+
+Please use the pagination parameters \`page_number\` and \`files_per_page\` wisely here.
+`),
+    page_number: page_number.describe(`
+The pagination page number. For now, in order to not break backwards compatibility in non-recursive imports, this only works when recursive is set to \`true\`.
+
+When doing big imports, make sure no files are added or removed from other scripts within your path, otherwise you might get weird results with the pagination.
+`),
+    files_per_page: files_per_page.describe(`
+The pagination page size. This only works when recursive is \`true\` for now, in order to not break backwards compatibility in non-recursive imports.
+`),
+  })
+  .strict()
+
+export type RobotWasabiImportInstructions = z.infer<typeof robotWasabiImportInstructionsSchema>
+export type RobotWasabiImportInstructionsInput = z.input<typeof robotWasabiImportInstructionsSchema>

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

@@ -0,0 +1,62 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse, wasabiBase } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 6,
+  discount_factor: 0.15000150001500018,
+  discount_pct: 84.99984999849998,
+  example_code: {
+    steps: {
+      exported: {
+        robot: '/wasabi/store',
+        use: ':original',
+        credentials: 'YOUR_WASABI_CREDENTIALS',
+        path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+      },
+    },
+  },
+  example_code_description: 'Export uploaded files to `my_target_folder` on Wasabi:',
+  has_small_icon: true,
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'File Exporting',
+  purpose_sentence: 'exports encoding results to Wasabi buckets',
+  purpose_verb: 'export',
+  purpose_word: 'Wasabi',
+  purpose_words: 'Export files to Wasabi',
+  service_slug: 'file-exporting',
+  slot_count: 10,
+  title: 'Export files to Wasabi',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+}
+
+export const robotWasabiStoreInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(wasabiBase)
+  .extend({
+    robot: z.literal('/wasabi/store').describe(`
+The URL to the result file will be returned in the <dfn>Assembly Status JSON</dfn>.
+`),
+    path: z.string().default('${unique_prefix}/${file.url_name}').describe(`
+The path at which the file is to be stored. This may include any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables). The path must not be a directory.
+`),
+    acl: z.enum(['private', 'public-read']).default('public-read').describe(`
+The permissions used for this file.
+`),
+    headers: z.record(z.string()).default({ 'Content-Type': '${file.mime}' }).describe(`
+An object containing a list of headers to be set for this file on Wasabi Spaces, such as \`{ FileURL: "\${file.url_name}" }\`. This can also include any available [Assembly Variables](/docs/topics/assembly-instructions/#assembly-variables).
+
+Object Metadata can be specified using \`x-amz-meta-*\` headers. Note that these headers [do not support non-ASCII metadata values](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#UserMetadata).
+`),
+    sign_urls_for: z.number().int().min(0).optional().describe(`
+This parameter provides signed URLs in the result JSON (in the \`signed_ssl_url\` property). The number that you set this parameter to is the URL expiry time in seconds. If this parameter is not used, no URL signing is done.
+`),
+  })
+  .strict()
+
+export type RobotWasabiStoreInstructions = z.infer<typeof robotWasabiStoreInstructionsSchema>
+export type RobotWasabiStoreInstructionsInput = z.input<typeof robotWasabiStoreInstructionsSchema>

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

@@ -0,0 +1,108 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 6,
+  discount_factor: 0.15000150001500018,
+  discount_pct: 84.99984999849998,
+  docs_redirect_from: ['/docs/export-to-youtube/'],
+  example_code: {
+    steps: {
+      exported: {
+        robot: '/youtube/store',
+        use: ':original',
+        credentials: 'YOUR_YOUTUBE_CREDENTIALS',
+        title: 'Transloadit: Video Example',
+        description: 'Some nice description',
+        category: 'science & technology',
+        keywords: 'transloadit, robots, botty',
+        visibility: 'private',
+      },
+    },
+  },
+  example_code_description: 'Export an uploaded video to YouTube and set some basic parameters:',
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'File Exporting',
+  purpose_sentence: 'exports encoding results to YouTube',
+  purpose_verb: 'export',
+  purpose_word: 'YouTube',
+  purpose_words: 'Export files to YouTube',
+  service_slug: 'file-exporting',
+  slot_count: 10,
+  title: 'Export files to YouTube',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+}
+
+export const robotYoutubeStoreInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/youtube/store').describe(`
+**Note:** This <dfn>Robot</dfn> only accepts videos. [{.alert .alert-note}]
+
+## Installation
+
+Since YouTube works with OAuth, you will need to generate [Template Credentials](/c/template-credentials/) to use this <dfn>Robot</dfn>.
+
+To change the \`title\`, \`description\`, \`category\`, or \`keywords\` per video, we recommend to [inject variables into your Template](/docs/topics/templates/).
+
+## Adding a thumbnail image to your video
+
+You can add a custom thumbnail to your video on YouTube by using our \`"as"\` syntax for the \`"use"\` parameter to supply both a video and an image to the step:
+
+\`\`\`json
+"exported": {
+  "use": [
+    { "name": "video_encode_step", "as": "video" },
+    { "name": "image_resize_step", "as": "image" },
+  ],
+  ...
+},
+\`\`\`
+
+If you encounter an error such as "The authenticated user doesnʼt have permissions to upload and set custom video thumbnails", you should go to your YouTube account and try adding a custom thumbnail to one of your existing videos. Youʼll be prompted to add your phone number. Once youʼve added it, the error should go away.
+`),
+    credentials: z.string().describe(`
+The authentication Template credentials used for your YouTube account. You can generate them on the [Template Credentials page](/c/template-credentials/). Simply add the name of your YouTube channel, and you will be redirected to a Google verification page. Accept the presented permissions and you will be good to go.
+`),
+    title: z.string().max(80).describe(`
+The title of the video to be displayed on YouTube.
+
+Note that since the YouTube API requires titles to be within 80 characters, longer titles may be truncated.
+`),
+    description: z.string().describe(`
+The description of the video to be displayed on YouTube. This can be up to 5000 characters, including \`\\n\` for new-lines.
+`),
+    category: z.enum([
+      'autos & vehicles',
+      'comedy',
+      'education',
+      'entertainment',
+      'film & animation',
+      'gaming',
+      'howto & style',
+      'music',
+      'news & politics',
+      'people & blogs',
+      'pets & animals',
+      'science & technology',
+      'sports',
+      'travel & events',
+    ]).describe(`
+The category to which this video will be assigned.
+`),
+    keywords: z.string().describe(`
+Tags used to describe the video, separated by commas. These tags will also be displayed on YouTube.
+`),
+    visibility: z.enum(['public', 'private', 'unlisted']).describe(`
+Defines the visibility of the uploaded video.
+`),
+  })
+  .strict()
+
+export type RobotYoutubeStoreInstructions = z.infer<typeof robotYoutubeStoreInstructionsSchema>
+export type RobotYoutubeStoreInstructionsInput = z.input<typeof robotYoutubeStoreInstructionsSchema>

package/src/alphalib/types/stackVersions.ts

@@ -0,0 +1,12 @@
+export const stackVersions = {
+  ffmpeg: {
+    recommendedVersion: 'v6' as const,
+    test: /^v?[56](\.\d+)?(\.\d+)?$/,
+    suggestedValues: ['v5', 'v6'] as const,
+  },
+  imagemagick: {
+    recommendedVersion: 'v3' as const,
+    test: /^v?[23](\.\d+)?(\.\d+)?$/,
+    suggestedValues: ['v2', 'v3'] as const,
+  },
+}

package/src/alphalib/types/template.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod'
+
+import { robotsWithHiddenBotsAndFieldsSchema, robotsSchema } from './robots/_index.ts'
+import type { RobotUse } from './robots/_instructions-primitives.ts'
+
+export const stepSchema = z
+  .object({
+    // This is a hack to get nicer robot hover messages in editors.
+    robot: z.string().describe('The [robot](https://transloadit.com/docs/transcoding/) to use'),
+  })
+  .and(robotsSchema)
+export const stepsSchema = z.record(stepSchema).describe('Contains Assembly Instructions.')
+export type Step = z.infer<typeof stepSchema>
+export type StepInput = z.input<typeof stepSchema>
+export type StepInputWithUse = StepInput & RobotUse
+export type Steps = z.infer<typeof stepsSchema>
+export type StepsInput = z.input<typeof stepsSchema>
+
+export const stepSchemaWithHiddenFields = z
+  .object({
+    // This is a hack to get nicer robot hover messages in editors.
+    robot: z.string().describe('The [robot](https://transloadit.com/docs/transcoding/) to use'),
+  })
+  .and(robotsWithHiddenBotsAndFieldsSchema)
+export const stepsSchemaWithHiddenFields = z
+  .record(stepSchemaWithHiddenFields)
+  .describe('Contains Assembly Instructions.')
+export type StepWithHiddenFields = z.infer<typeof stepSchemaWithHiddenFields>
+export type StepWithHiddenFieldsInput = z.input<typeof stepSchemaWithHiddenFields>
+export type StepsWithHiddenFields = z.infer<typeof stepsSchemaWithHiddenFields>
+export type StepsWithHiddenFieldsInput = z.input<typeof stepsSchemaWithHiddenFields>
+
+export const assemblyAuthInstructionsSchema = z.object({
+  key: z.string().describe('The Transloadit API key to use'),
+  secret: z.string().optional().describe('The Transloadit API secret to use'),
+  expires: z.string().optional().describe('The Transloadit API expires to use'),
+  max_size: z.number().optional().describe('The Transloadit API max_size to use'),
+})
+
+export const assemblyInstructionsSchema = z.object({
+  auth: assemblyAuthInstructionsSchema.optional(),
+  allow_steps_override: z
+    .boolean()
+    .optional()
+    .describe(
+      'Set this to false to disallow Overruling Templates at Runtime. If you set this to false then template_id and steps will be mutually exclusive and you may only supply one of those parameters. Recommended when deploying Transloadit in untrusted environments. This makes sense to set as part of a Template, rather than on the Assembly itself when creating it.',
+    ),
+  notify_url: z
+    .string()
+    .optional()
+    .describe(
+      'Transloadit can send a Pingback to your server when the Assembly is completed. We’ll send the Assembly status in a form url-encoded JSON string inside of a transloadit field in a multipart POST request to the URL supplied here.',
+    ),
+  fields: z
+    .record(z.any())
+    .optional()
+    .describe(
+      'An object of string keyed values (name -> value) that can be used as Assembly Variables, just like additional form fields can. You can use anything that is JSON stringifyable as a value',
+    ),
+  quiet: z
+    .boolean()
+    .optional()
+    .describe(
+      'Set this to true to reduce the response from an Assembly POST request to only the necessary fields. This prevents any potentially confidential information being leaked to the end user who is making the Assembly request. A successful Assembly will only include the ok and assembly_id fields. An erroneous Assembly will only include the error, http_code, message and assembly_id fields. The full Assembly Status will then still be sent to the notify_url if one was specified.',
+    ),
+  steps: stepsSchema.optional(),
+  template_id: z.string().optional().describe('The Template ID to use'),
+})
+
+export type AssemblyInstructions = z.infer<typeof assemblyInstructionsSchema>
+export type AssemblyInstructionsInput = z.input<typeof assemblyInstructionsSchema>