@transloadit/zod 4.4.1 → 5.0.0

package/dist/v4/robots/_instructions-primitives.js

@@ -1,5 +1,9 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { stackVersions } from "../stackVersions.js";
+import { formatEnglishList } from "../englishList.js";
+import { ecmaWhitespaceCharacterClass, zodInputPreservingTransform, zodWithConservativeJsonInputSchema, zodWithJsonInputSchema, } from "../lib/zodInputSemantics.js";
+import { inheritApiParameterDescription } from "../apiParameterDescription.js";
+import { runtimeStackVersions, stackVersions } from "../stackVersions.js";
 export const robotNames = z.enum([
     'AiChatRobot',
     'UploadHandleRobot',
@@ -76,6 +80,7 @@ export const robotNames = z.enum([
     'DropboxImportRobot',
     'DropboxStoreRobot',
     'HttpImportRobot',
+    'HttpRequestRobot',
     'SftpImportRobot',
     'SftpStoreRobot',
     'FtpImportRobot',
@@ -98,61 +103,50 @@ export const robotNames = z.enum([
     'TextSpeakRobot',
     'TextTranslateRobot',
     'FilePreviewRobot',
+    'TusStoreRobot',
     'TransloaditImportRobot',
     'TransloaditStoreRobot',
-    'TusStoreRobot',
     'ProgressSimulateRobot',
 ]);
+const awsGcpMinimumChargeUsdSchema = z.object({
+    aws: z.number(),
+    gcp: z.number(),
+});
 export const robotMetaSchema = z.object({
     // Added keys from api2/lib/config.ts:
     name: robotNames,
     priceFactor: z.number(),
     queueSlotCount: z.number(),
-    downloadInputFiles: z.boolean().optional(),
-    preserveInputFileUrls: z.boolean().optional(),
-    minimumCharge: z.number().optional(),
-    minimumChargeUsd: z.number().optional(),
-    minimumChargeUsdPerSpeechTranscribeMinute: z
-        .object({
-        aws: z.number(),
-        gcp: z.number(),
-    })
-        .optional(),
-    minimumChargeUsdPerDocumentOcrPage: z
-        .object({
-        aws: z.number(),
-        gcp: z.number(),
-    })
-        .optional(),
-    applyCommunityPlanMediaTrim: z.boolean().optional(),
+    downloadInputFiles: optionalWithV3Semantics(z.boolean()),
+    preserveInputFileUrls: optionalWithV3Semantics(z.boolean()),
+    minimumCharge: optionalWithV3Semantics(z.number()),
+    minimumChargeUsd: optionalWithV3Semantics(z.number()),
+    minimumChargeUsdPerSpeechTranscribeMinute: optionalWithV3Semantics(awsGcpMinimumChargeUsdSchema
+        .extend({
+        replicate: optionalWithV3Semantics(z.literal('variable')),
+    })),
+    minimumChargeUsdPerDocumentOcrPage: optionalWithV3Semantics(awsGcpMinimumChargeUsdSchema),
+    applyCommunityPlanMediaTrim: optionalWithV3Semantics(z.boolean()),
     isAllowedForUrlTransform: z.boolean(),
     removeJobResultFilesFromDiskRightAfterStoringOnS3: z.boolean(),
-    lazyLoad: z.boolean().optional(),
-    installVersionFile: z.string().optional(),
-    trackOutputFileSize: z.boolean().optional(),
+    lazyLoad: optionalWithV3Semantics(z.boolean()),
+    installVersionFile: optionalWithV3Semantics(z.string()),
+    trackOutputFileSize: optionalWithV3Semantics(z.boolean()),
     isInternal: z.boolean(),
-    numDaemons: z.number().optional(),
+    numDaemons: optionalWithV3Semantics(z.number()),
     stage: z.enum(['alpha', 'beta', 'ga', 'deprecated', 'removed']),
-    importRanges: z.array(z.string()).optional(),
-    extraChargeForImageResize: z.number().optional(),
+    importRanges: optionalWithV3Semantics(z.array(z.string())),
+    extraChargeForImageResize: optionalWithV3Semantics(z.number()),
     // Original keys from content repo:
-    bytescount: z.number(),
-    description: z.string().optional(),
-    discount_factor: z.number(),
-    discount_pct: z.number(),
-    // To avoid a cycling dependency back to template.ts, we'll use any for now:
-    // example_code: assemblyInstructionsSchema.optional(),
-    example_code: z.any().optional(),
-    example_code_description: z.string().optional(),
-    extended_description: z.string().optional(),
-    has_small_icon: z.literal(true).optional(),
-    minimum_charge: z.number(),
-    minimum_charge_usd: z.union([z.number(), z.record(z.string(), z.number())]).optional(),
-    minimum_charge_usd_note: z.string().optional(),
-    ogimage: z.string().optional(),
-    marketing_intro: z.string().optional(),
-    output_factor: z.number(),
-    override_lvl1: z.string().optional(),
+    description: optionalWithV3Semantics(z.string()),
+    // Validate against assembled public Robot schemas at publication, outside this dependency cycle.
+    example_code: optionalWithV3Semantics(z.unknown()),
+    example_code_description: optionalWithV3Semantics(z.string()),
+    extended_description: optionalWithV3Semantics(z.string()),
+    has_small_icon: optionalWithV3Semantics(z.literal(true)),
+    ogimage: optionalWithV3Semantics(z.string()),
+    marketing_intro: optionalWithV3Semantics(z.string()),
+    override_lvl1: optionalWithV3Semantics(z.string()),
     purpose_sentence: z.string(),
     purpose_verb: z.enum([
         'auto-rotate',
@@ -193,8 +187,8 @@ export const robotMetaSchema = z.object({
     ]),
     purpose_word: z.string(),
     purpose_words: z.string(),
-    hideCredentialsWarning: z.boolean().optional(),
-    requires_credentials: z.literal(true).optional(),
+    hideCredentialsWarning: optionalWithV3Semantics(z.boolean()),
+    requires_credentials: optionalWithV3Semantics(z.literal(true)),
     service_slug: z.enum([
         'artificial-intelligence',
         'audio-encoding',
@@ -206,11 +200,10 @@ export const robotMetaSchema = z.object({
         'file-filtering',
         'file-importing',
         'handling-uploads',
-        'image-manipulation',
+        'image-processing',
         'media-cataloging',
         'video-encoding',
     ]),
-    slot_count: z.number(),
     title: z.string(),
     typical_file_size_mb: z.number(),
     typical_file_type: z.enum([
@@ -222,8 +215,160 @@ export const robotMetaSchema = z.object({
         'video',
         'webpage',
     ]),
-    uses_tools: z.array(z.enum(['ffmpeg', 'imagemagick'])).optional(),
+    uses_tools: optionalWithV3Semantics(z.array(z.enum(['ffmpeg', 'imagemagick']))),
 });
+/** Shared processing metadata; per-Robot exceptions stay explicit. */
+export const robotProcessingMeta = {
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+    queueSlotCount: 10,
+    priceFactor: 1,
+    isAllowedForUrlTransform: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+/** Shared artificial-intelligence metadata; exceptions stay local. */
+export const robotArtificialIntelligenceMeta = {
+    ...robotProcessingMeta,
+    service_slug: 'artificial-intelligence',
+    typical_file_type: 'image',
+    trackOutputFileSize: true,
+};
+/** Shared audio-encoding metadata; exceptions stay local. */
+export const robotAudioEncodingMeta = {
+    ...robotProcessingMeta,
+    override_lvl1: 'Audio Encoding',
+    service_slug: 'audio-encoding',
+    typical_file_size_mb: 3.8,
+    typical_file_type: 'audio file',
+    priceFactor: 4,
+    queueSlotCount: 20,
+    trackOutputFileSize: true,
+    applyCommunityPlanMediaTrim: true,
+};
+/** Shared document-processing metadata; exceptions stay local. */
+export const robotDocumentProcessingMeta = {
+    ...robotProcessingMeta,
+    override_lvl1: 'Document Processing',
+    service_slug: 'document-processing',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'document',
+    minimumCharge: 1048576,
+};
+/** Shared content-delivery metadata; exceptions stay local. */
+export const robotContentDeliveryMeta = {
+    ...robotProcessingMeta,
+    service_slug: 'content-delivery',
+    queueSlotCount: 0,
+    downloadInputFiles: false,
+    preserveInputFileUrls: true,
+    isAllowedForUrlTransform: false,
+    trackOutputFileSize: false,
+    isInternal: true,
+};
+/** Shared file-filtering metadata; exceptions stay local. */
+export const robotFileFilteringMeta = {
+    ...robotProcessingMeta,
+    override_lvl1: 'File Filtering',
+    service_slug: 'file-filtering',
+    trackOutputFileSize: true,
+};
+/** Shared media-cataloging metadata; exceptions stay local. */
+export const robotMediaCatalogingMeta = {
+    ...robotProcessingMeta,
+    override_lvl1: 'Media Cataloging',
+    service_slug: 'media-cataloging',
+    queueSlotCount: 15,
+};
+/** Shared image-processing metadata; exceptions stay local. */
+export const robotImageProcessingMeta = {
+    ...robotProcessingMeta,
+    override_lvl1: 'Image Processing',
+    service_slug: 'image-processing',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'image',
+};
+/** Shared code-evaluation metadata; exceptions stay local. */
+export const robotCodeEvaluationMeta = {
+    ...robotProcessingMeta,
+    override_lvl1: 'Code Evaluation',
+    service_slug: 'code-evaluation',
+    isAllowedForUrlTransform: false,
+    trackOutputFileSize: true,
+};
+/** Shared video-encoding metadata; exceptions stay local. */
+export const robotVideoEncodingMeta = {
+    ...robotProcessingMeta,
+    override_lvl1: 'Video Encoding',
+    service_slug: 'video-encoding',
+    typical_file_size_mb: 80,
+    typical_file_type: 'video',
+    queueSlotCount: 60,
+    isAllowedForUrlTransform: false,
+    trackOutputFileSize: true,
+    applyCommunityPlanMediaTrim: true,
+};
+/** Shared import metadata; provider-specific prices, queues, and flags override it locally. */
+export const robotImportMeta = {
+    override_lvl1: 'File Importing',
+    purpose_verb: 'import',
+    service_slug: 'file-importing',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+    priceFactor: 6.6666,
+    queueSlotCount: 20,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: false,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+    stage: 'ga',
+};
+/** Shared store metadata; provider-specific prices, queues, and flags override it locally. */
+export const robotStoreMeta = {
+    override_lvl1: 'File Exporting',
+    purpose_verb: 'export',
+    service_slug: 'file-exporting',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+    priceFactor: 6.6666,
+    queueSlotCount: 10,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: false,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+/** Single-Step processing example; unusual input relationships stay explicit. */
+export function createProcessingExample(name, robot, parameters = {}) {
+    return { steps: { [name]: { robot, use: ':original', ...parameters } } };
+}
+/** Standard directory import example; nonrecursive providers omit the flag. */
+export function createStorageImportExample(robot, credentials, recursive = true) {
+    return {
+        steps: {
+            imported: {
+                robot,
+                credentials,
+                path: 'path/to/files/',
+                ...(recursive ? { recursive: true } : {}),
+            },
+        },
+    };
+}
+/** Standard export example shared by compatible storage providers. */
+export function createStorageStoreExample(robot, credentials) {
+    return {
+        steps: {
+            exported: {
+                robot,
+                use: ':original',
+                credentials,
+                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+            },
+        },
+    };
+}
 // These schemas can be reproduced with z.string().regex(). However, this causes some issues.
 // We use this in combination with unions. Internally Zod normalizes unions. A string schema and
 // enums merged in some way. Both are validated. Normally, if a Zod union has errors, all of them
@@ -233,20 +378,10 @@ export const robotMetaSchema = z.object({
 // is more useful in pretty much every case. To work around this, we use z.custom() instead, as Zod
 // can’t normalize that.
 const interpolationRegexFull = /^\${.+}$/;
-export const interpolationSchemaFull = z.custom((input) => typeof input === 'string' && interpolationRegexFull.test(input), 'Must be a full interpolation string');
+export const interpolationSchemaFull = zodWithJsonInputSchema(z.custom((input) => typeof input === 'string' && interpolationRegexFull.test(input), 'Must be a full interpolation string'), z.string().regex(/^\$\{[^\n\r\u2028\u2029]+\}$/u));
 const interpolationRegexPartial = /\${.+}/;
-export const interpolationSchemaPartial = z.custom((input) => typeof input === 'string' && interpolationRegexPartial.test(input), 'Must be a partially interpolatable string');
+export const interpolationSchemaPartial = zodWithJsonInputSchema(z.custom((input) => typeof input === 'string' && interpolationRegexPartial.test(input), 'Must be a partially interpolatable string'), z.string().regex(/\$\{[^\n\r\u2028\u2029]+\}/u));
 export const booleanStringSchema = z.enum(['true', 'false']);
-export const inputSortBySchema = z
-    .enum(['auto', 'basename', 'import_order'])
-    .default('basename')
-    .describe(`
-Controls how bundled inputs are ordered when no explicit numbered alias such as \`video_1\` or \`document_1\` is used.
-
-The default \`"basename"\` keeps the legacy natural basename sorting behavior.
-
-Set this to \`"import_order"\` to preserve the order of array-based import steps when all input files carry complete import order metadata. \`"auto"\` has the same import-order preference with natural basename sorting as fallback.
-`);
 const applyArrayChecks = (schema, checks) => {
     if (!Array.isArray(checks))
         return schema;
@@ -267,7 +402,7 @@ const applyArrayChecks = (schema, checks) => {
     }
     return next;
 };
-export function interpolateRecursive(schema) {
+function interpolateRecursiveWithoutDescriptionRegistration(schema) {
     const def = schema._zod.def;
     switch (def.type) {
         case 'boolean':
@@ -275,7 +410,7 @@ export function interpolateRecursive(schema) {
                 interpolationSchemaFull,
                 z
                     .union([schema, booleanStringSchema])
-                    .transform((value) => value === true || value === false),
+                    .transform((value) => value === true || value === 'true'),
             ]);
         case 'array': {
             const arrayDef = def;
@@ -283,11 +418,10 @@ export function interpolateRecursive(schema) {
             replacement = applyArrayChecks(replacement, arrayDef.checks);
             return z.union([interpolationSchemaFull, replacement]);
         }
-        case 'default': {
+        case 'default':
+        case 'prefault': {
             const defaultDef = def;
-            const replacement = interpolateRecursive(defaultDef.innerType).default(defaultDef.defaultValue);
-            const description = schema.description;
-            return (description ? replacement.describe(description) : replacement);
+            return interpolateRecursive(defaultDef.innerType).prefault(() => defaultDef.defaultValue);
         }
         case 'enum':
         case 'literal':
@@ -327,7 +461,7 @@ export function interpolateRecursive(schema) {
         }
         case 'optional': {
             const optionalDef = def;
-            return interpolateRecursive(optionalDef.innerType).optional();
+            return optionalWithV3Semantics(interpolateRecursive(optionalDef.innerType));
         }
         case 'record': {
             const recordDef = def;
@@ -352,17 +486,27 @@ export function interpolateRecursive(schema) {
             }
             return z.union([interpolationSchemaFull, ...unionDef.options.map(interpolateRecursive)]);
         }
-        case 'pipe':
-            return z.union([interpolationSchemaFull, schema]);
+        case 'pipe': {
+            const pipeDef = def;
+            return z.union([pipeDef.in instanceof z.ZodString ? interpolationSchemaPartial : interpolationSchemaFull, schema]);
+        }
         default:
             return schema;
     }
 }
+/** Keep parameter help on rebuilt interpolation schemas. */
+export function interpolateRecursive(schema) {
+    // Conditional core types lose the classic Zod methods in generic constraints; every
+    // runtime branch above constructs a classic schema and describe preserves its type.
+    const interpolated = interpolateRecursiveWithoutDescriptionRegistration(schema);
+    return inheritApiParameterDescription(schema, interpolated);
+}
 /**
  * The robot keys specified in this array can’t be interpolated.
  */
 const uninterpolatableKeys = ['interpolate', 'robot', 'use'];
 const uninterpolatableKeySet = new Set(uninterpolatableKeys);
+const robotIdentifierDescription = 'Identifier of the [robot](https://transloadit.com/docs/robots/) to execute';
 export function interpolateRobot(schema) {
     const def = schema._zod.def;
     const shape = typeof def.shape === 'function'
@@ -377,18 +521,17 @@ export function interpolateRobot(schema) {
     ])))
         .strict();
 }
-const robotInterpolateBooleanSchema = z
-    .union([z.boolean(), booleanStringSchema])
-    .transform((value) => value === true || value === 'true');
-export const robotInterpolateSchema = z
-    .union([robotInterpolateBooleanSchema, z.record(z.string(), robotInterpolateBooleanSchema)])
-    .describe(`
+const robotInterpolateBooleanSchema = zodInputPreservingTransform(z.union([z.boolean(), booleanStringSchema]), (value) => value === true || value === 'true');
+const robotInterpolateDescription = `
 Controls whether Assembly Variables are interpolated for individual instruction fields.
 
 By default, most Robot instruction fields interpolate Assembly Variables. Set this to \`false\` to treat every instruction field as literal text, or set an individual field path to \`false\` to treat only that field as literal text. For Robot-specific fields that are literal by default, set this to \`true\` or set that field path to \`true\` to opt back into interpolation.
 
 Use field names such as \`path\`, or dotted paths such as \`ffmpeg.vf\` for nested objects.
-`);
+`;
+export const robotInterpolateSchema = z
+    .union([robotInterpolateBooleanSchema, z.record(z.string(), robotInterpolateBooleanSchema)])
+    .describe(robotInterpolateDescription);
 /**
  * Fields that are shared by all Transloadit robots.
  */
@@ -397,36 +540,92 @@ export const robotOutputMetaSchema = z.union([
     z.boolean(),
     z.array(z.string()),
 ]);
-export const robotBase = z
-    .object({
-    interpolate: robotInterpolateSchema.optional(),
-    output_meta: robotOutputMetaSchema.optional().describe(`
+const robotOutputMetaDescription = `
 Allows you to specify a set of metadata that is more expensive on CPU power to calculate, and thus is disabled by default to keep your Assemblies processing fast.
 
 For images, you can add \`"has_transparency": true\` in this object to extract if the image contains transparent parts and \`"dominant_colors": true\` to extract an array of hexadecimal color codes from the image.
 
 For images, you can also add \`"blurhash": true\` to extract a [BlurHash](https://blurha.sh) string — a compact representation of a placeholder for the image, useful for showing a blurred preview while the full image loads.
 
-For videos, you can add the \`"colorspace: true"\` parameter to extract the colorspace of the output video.
+For images, \`"thumbhash": true\` instead extracts a base64-encoded [ThumbHash](https://evanw.github.io/thumbhash/) into \`meta.thumbhash\`, together with \`meta.has_alpha\` (whether an alpha channel exists, even when fully opaque). It describes EXIF-oriented pixels and uses the first frame of animated images. Extraction is best-effort: images above 40 megapixels, unsupported formats, or a failed/bounded decode produce no placeholder. Successful extraction adds a metadata charge equivalent to 20% of that file's bytes. No ThumbHash surcharge applies when disabled or when no hash is produced.
+
+Set this option on the Step producing the image, such as \`/upload/handle\` for uploaded originals or \`/image/resize\` for processed outputs. Setting it only on \`/transloadit/store\` does not request extraction: storage preserves the producer's metadata. Transloadit Storage persists a generated hash with its immutable version and returns it in stored results and native asset reads. Direct S3 uploads do not generate placeholders. A placeholder contains image information, so protect it with the same access controls as the full image.
+
+For videos, you can add the \`"colorspace": true\` parameter to extract the colorspace of the output video.
 
 For videos, you can also add \`"interlaced": true\` to detect whether the video is interlaced. This combines the cheap ffprobe \`field_order\` flag with a bounded \`idet\` sampling pass over the first frames of the source, exposing \`interlaced\`, \`field_order\`, and a diagnostic \`interlace_detection\` object under \`file.meta\`. This is computationally expensive and billed accordingly.
 
 For audio, you can add \`"mean_volume": true\` to get a single value representing the mean average volume of the audio file.
 
 You can also set this to \`false\` to skip metadata extraction and speed up transcoding.
-`),
-    result: z
-        .boolean()
-        .default(false)
-        .describe('Whether the results of this Step should be present in the Assembly Status JSON'),
-    queue: z
-        .enum(['batch'])
-        .optional()
-        .describe(`Setting the queue to 'batch', manually downgrades the priority of jobs for this step to avoid consuming Priority job slots for jobs that don't need zero queue waiting times`),
-    force_accept: z
-        .boolean()
-        .default(false)
-        .describe(`Force a Robot to accept a file type it would have ignored.
+`;
+const robotQueueDescription = `Setting the queue to 'batch', manually downgrades the priority of jobs for this step to avoid consuming Priority job slots for jobs that don't need zero queue waiting times`;
+const robotIgnoreErrorsPhaseDescriptions = `Ignore errors during specific phases of processing.
+
+Setting this to \`["meta"]\` will cause the Robot to ignore errors during metadata extraction.
+
+Setting this to \`["execute"]\` will cause the Robot to ignore errors during the main execution phase.`;
+export const autoProviderDescription = 'Chooses the best provider based on your request.';
+const aiProviderDescription = `${autoProviderDescription}
+
+Select a specific provider to override automatic selection.`;
+const legacyFfmpegVersions = formatEnglishList(runtimeStackVersions.ffmpeg.valid.map((version) => JSON.stringify(version)));
+const deprecatedFfmpegVersions = formatEnglishList([
+    ...new Set(Object.keys(runtimeStackVersions.ffmpeg.deprecated).map((version) => JSON.stringify(`${version.split('.')[0]}.x`))),
+]);
+export const robotParameterDocs = {
+    adaptive_filtering: {
+        description: `
+Controls the image compression for PNG images. Setting to \`true\` results in smaller file size, while increasing processing time. It is encouraged to keep this option disabled.
+`,
+    },
+    ai_provider: {
+        description: aiProviderDescription,
+    },
+    audio_bitrate: {
+        description: `
+Bit rate of the resulting audio file, in bits per second. If not specified will default to the bit rate of the input audio file.
+`,
+    },
+    audio_preset: {
+        description: `
+Performs conversion using pre-configured settings.
+
+If you specify your own FFmpeg parameters using the <dfn>Robot</dfn>'s \`ffmpeg\` parameter and you have not specified a preset, then the default \`mp3\` preset is not applied. This is to prevent you from having to override each of the MP3 preset's values manually.
+
+For a list of audio presets, see [audio presets](/docs/presets/audio/).
+`,
+    },
+    audio_sample_rate: {
+        description: `
+Sample rate of the resulting audio file, in Hertz. If not specified will default to the sample rate of the input audio file.
+`,
+    },
+    auto_provider: {
+        description: autoProviderDescription,
+    },
+    error_msg: {
+        description: `
+The error message shown to your users (such as by Uppy) when a file is declined and \`error_on_decline\` is set to \`true\`.
+`,
+    },
+    error_on_decline: {
+        description: `
+If this is set to \`true\` and one or more files are declined, the Assembly will be stopped and marked with an error.
+`,
+    },
+    ffmpeg: {
+        description: `
+A parameter object to be passed to FFmpeg. If a preset is used, the options specified are merged on top of the ones from the preset. For available options, see the [FFmpeg documentation](https://ffmpeg.org/ffmpeg-doc.html). Options specified here take precedence over the preset options.
+`,
+    },
+    ffmpeg_stack: {
+        description: `
+Selects the FFmpeg stack version to use for encoding. We currently recommend using "${stackVersions.ffmpeg.recommendedVersion}". The exact versions ${legacyFfmpegVersions} are legacy values that remain accepted for backward compatibility. Deprecated ${deprecatedFfmpegVersions} values are also accepted.
+`,
+    },
+    force_accept: {
+        description: `Force a Robot to accept a file type it would have ignored.
 
 By default, Robots ignore files they are not familiar with.
 [🤖/video/encode](/docs/robots/video-encode/), for
@@ -434,27 +633,228 @@ example, will happily ignore input images.
 
 With the \`force_accept\` parameter set to \`true\`, you can force Robots to accept all files thrown at them.
 This will typically lead to errors and should only be used for debugging or combatting edge cases.
-`),
-    ignore_errors: z
-        .union([z.boolean(), z.array(z.enum(['meta', 'execute']))])
-        .transform((value) => (value === true ? ['meta', 'execute'] : value === false ? [] : value))
-        .default([])
-        .describe(`
-Ignore errors during specific phases of processing.
+`,
+    },
+    force_name: {
+        description: 'Custom name for the imported file(s). By default file names are derived from the source.',
+    },
+    ignore_errors: {
+        description: `
+${robotIgnoreErrorsPhaseDescriptions}
 
-Setting this to \`["meta"]\` will cause the Robot to ignore errors during metadata extraction.
+Setting this to \`true\` is equivalent to \`["meta", "execute"]\` and will ignore errors in both phases.
+`,
+    },
+    import_ignore_errors: {
+        description: `
+${robotIgnoreErrorsPhaseDescriptions}
 
-Setting this to \`["execute"]\` will cause the Robot to ignore errors during the main execution phase.
+Setting this to \`["import"]\` will cause the Robot to ignore errors while importing the source file. The \`"import"\` phase is only available to import Robots.
 
-Setting this to \`true\` is equivalent to \`["meta", "execute"]\` and will ignore errors in both phases.
-`),
+Setting this to \`true\` is equivalent to \`["meta", "import", "execute"]\` and will ignore errors in all three phases.
+`,
+    },
+    import_on_errors: {
+        description: `
+Setting this to \`["meta"]\` will still import the file on metadata extraction errors. \`ignore_errors\` is similar, it also ignores the error and makes sure the Robot doesn't stop, but it doesn't import the file.
+`,
+    },
+    interpolate: {
+        description: robotInterpolateDescription,
+    },
+    ocr_format: {
+        description: `
+In what format to return the extracted text.
+- \`"json"\` returns a JSON file.
+- \`"meta"\` does not return a file, but stores the data inside Transloadit's file object (under \`\${file.meta.recognized_text}\`, which is an array of strings) that's passed around between encoding <dfn>Steps</dfn>, so that you can use the values to burn the data into videos, filter on them, etc.
+- \`"text"\` returns the recognized text as a plain UTF-8 encoded text file.
+`,
+    },
+    ocr_granularity: {
+        description: `
+Whether to return a full response including coordinates for the text (\`"full"\`), or a flat list of the extracted phrases (\`"list"\`). This parameter has no effect if the \`format\` parameter is set to \`"text"\`.
+`,
+    },
+    ocr_provider: {
+        description: `${aiProviderDescription}
+AWS supports detection for the following languages: English, Arabic, Russian, German, French, Italian, Portuguese and Spanish. GCP allows for a wider range of languages, with varying levels of support which can be found on the [official documentation](https://cloud.google.com/vision/docs/languages/).
+`,
+    },
+    output_meta: {
+        description: robotOutputMetaDescription,
+    },
+    queue: {
+        description: robotQueueDescription,
+    },
+    result: {
+        description: 'Whether the results of this Step should be present in the Assembly Status JSON',
+    },
+    return_file_stubs: {
+        description: `
+If set to \`true\`, the Robot will not yet import the actual files but instead return an empty file stub that includes a URL from where the file can be imported by subsequent Robots. This is useful for cases where subsequent Steps need more control over the import process, such as with 🤖/video/ondemand. This parameter should only be set if all subsequent Steps use Robots that support file stubs.
+`,
+    },
+    robot: {
+        description: `
+Specifies which Robot should process files passed to this Step.
+
+See [all Robots](https://transloadit.com/docs/robots/), each with their own parameters, such as
+\`width\` to control how an image is resized. The full list of parameters per Robot can be taken
+from the Robot docs.
+`,
+    },
+    seed: {
+        description: 'Seed for the random number generator.',
+    },
+    sort_by: {
+        description: `
+Controls how bundled inputs are ordered when no explicit numbered alias for the input type is used. Numbered aliases end with a numeric suffix such as \`_1\`.
+
+The default \`"basename"\` keeps the legacy natural basename sorting behavior.
+
+Set this to \`"import_order"\` to preserve the order of array-based import steps when all input files carry complete import order metadata. \`"auto"\` has the same import-order preference with natural basename sorting as fallback.
+`,
+    },
+    use: {
+        description: `
+Specifies which Step(s) to use as input.
+
+- You can pick any names for Steps except \`":original"\` (reserved for user uploads handled by Transloadit)
+- You can provide several Steps as input with arrays:
+  \`\`\`json
+  {
+    "use": [
+      ":original",
+      "encoded",
+      "resized"
+    ]
+  }
+  \`\`\`
+- You can also tag input Steps with \`as\` to pass semantic intent to robots:
+  \`\`\`json
+  {
+    "use": [
+      {
+        "name": ":original",
+        "as": "image"
+      },
+      {
+        "name": ":original",
+        "as": "mask"
+      }
+    ]
+  }
+  \`\`\`
+
+> [!Tip]
+> That's likely all you need to know about \`use\`, but you can view [Advanced use cases](/docs/topics/use-parameter/).
+`,
+    },
+    user_meta: {
+        description: `
+Adds custom JSON metadata to each emitted file without changing its contents. Nested objects and arrays are supported.
+
+Inheritance depends on the Robot. Values merge with existing \`user_meta\` on the output file; the current Step replaces matching top-level keys. Assign required keys explicitly when a Robot creates fresh outputs.
+
+In processing Steps, \`\${file.*}\` refers to the first input and \`\${result.*}\` to the emitted file. Values are evaluated per output after the Robot runs, before subsequent metadata extraction and temporary storage. On \`:original\`, values are evaluated per upload before metadata extraction.
+
+Downstream Steps read \`\${file.user_meta.key}\`. See [Custom metadata](https://transloadit.com/docs/topics/assembly-variables/#user-meta) for a complete example and inheritance rules.
+`,
+    },
+    video_background: {
+        description: `
+The background color of the resulting video in the \`"rrggbbaa"\` format (red, green, blue, alpha) when used with the \`"pad"\` resize strategy. The default color is black.
+`,
+    },
+    video_height: {
+        description: `
+Height of the new video, in pixels.
+
+If the value is not specified and the \`preset\` parameter is available, the \`preset\`'s [supplied height](/docs/presets/video/) will be implemented.
+`,
+    },
+    video_preset: {
+        description: `
+Converts a video according to [pre-configured settings](/docs/presets/video/).
+
+You can use the value \`'empty'\` here if you specify your own FFmpeg parameters using the <dfn>Robot</dfn> or do not want Transloadit to set any encoding settings.
+`,
+    },
+    video_width: {
+        description: `
+Width of the new video, in pixels.
+
+If the value is not specified and the \`preset\` parameter is available, the \`preset\`'s [supplied width](/docs/presets/video/) will be implemented.
+`,
+    },
+};
+export const inputSortBySchema = z
+    .enum(['auto', 'basename', 'import_order'])
+    .default('basename')
+    .describe(robotParameterDocs.sort_by.description);
+export const robotPathSchema = z
+    .string()
+    .regex(/^\/[a-z0-9_-]+\/[a-z0-9_-]+$/u)
+    .describe(robotParameterDocs.robot.description);
+export const robotBase = z
+    .object({
+    interpolate: optionalWithV3Semantics(robotInterpolateSchema),
+    output_meta: optionalWithV3Semantics(robotOutputMetaSchema)
+        .describe(robotParameterDocs.output_meta.description),
+    user_meta: z.record(z.string(), z.unknown()).default({}).describe(robotParameterDocs.user_meta.description),
+    result: z.boolean().default(false).describe(robotParameterDocs.result.description),
+    queue: optionalWithV3Semantics(z.enum(['batch'])).describe(robotParameterDocs.queue.description),
+    force_accept: z.boolean().default(false).describe(robotParameterDocs.force_accept.description),
+    ignore_errors: zodInputPreservingTransform(z.union([z.boolean(), z.array(z.enum(['meta', 'execute']))]), (value) => (value === true ? ['meta', 'execute'] : value === false ? [] : value))
+        .default([])
+        .describe(robotParameterDocs.ignore_errors.description),
 })
     .strict();
+/**
+ * Standard variants for strict Robot instructions without catchalls. Keep this outside the adapter
+ * replaced by the SDK's Zod 4 sync. Inference uses the active Zod version's object types.
+ */
+export function createRobotSchemaVariants(schema) {
+    const strictSchema = schema.strict();
+    const result = schema.shape.result;
+    const withHiddenFields = strictSchema
+        .merge(z.object({ result: optionalWithV3Semantics(z.union([z.literal('debug'), result])) }))
+        .strict();
+    return {
+        schema,
+        withHiddenFields,
+        interpolatable: interpolateRobot(strictSchema),
+        interpolatableWithHiddenFields: interpolateRobot(withHiddenFields),
+    };
+}
+/** Standard strict variants with extra internal fields. */
+export function extendRobotSchemaVariants(schema, hiddenFields) {
+    const strictSchema = schema.strict();
+    const result = schema.shape.result;
+    const withHiddenFields = strictSchema.extend({
+        result: optionalWithV3Semantics(z.union([z.literal('debug'), result])),
+        ...hiddenFields,
+    });
+    return {
+        schema,
+        withHiddenFields,
+        interpolatable: interpolateRobot(strictSchema),
+        interpolatableWithHiddenFields: interpolateRobot(withHiddenFields),
+    };
+}
+/** Define a strict Robot's schema variants together with its metadata. */
+export function defineRobot(meta, schema) {
+    return { meta, ...createRobotSchemaVariants(schema) };
+}
+/** Define a strict Robot with extra internal fields and its metadata. */
+export function defineRobotWithHiddenFields(meta, schema, hiddenFields) {
+    return { meta, ...extendRobotSchemaVariants(schema, hiddenFields) };
+}
 export const useParamObjectSchema = z
     .object({
     name: z.string(),
-    fields: z.string().optional(),
-    as: z.string().optional(),
+    fields: optionalWithV3Semantics(z.string()),
+    as: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const useParamStringSchema = z.string();
@@ -468,11 +868,10 @@ export const useParamStepsSchema = z.union([
 export const useParamObjectOfStepsSchema = z
     .object({
     steps: useParamStepsSchema,
-    bundle_steps: z.boolean().optional(),
-    group_by_original: z.boolean().optional(),
-    fields: z
-        .array(z.string())
-        .optional()
+    bundle_steps: optionalWithV3Semantics(z.boolean()),
+    group_by_original: optionalWithV3Semantics(z.boolean()),
+    fields: optionalWithV3Semantics(z
+        .array(z.string()))
         .describe(`
 Array of field names to filter input files by when using steps.
 `),
@@ -480,7 +879,7 @@ Array of field names to filter input files by when using steps.
     .strict();
 // Hidden fields variants for use parameters
 export const useParamObjectWithHiddenFieldsSchema = useParamObjectSchema.extend({
-    result: z.union([z.literal('debug'), z.boolean()]).optional(),
+    result: optionalWithV3Semantics(z.union([z.literal('debug'), z.boolean()])),
 });
 export const useParamArrayOfUseParamObjectWithHiddenFieldsSchema = z.array(useParamObjectWithHiddenFieldsSchema);
 export const useParamStepsWithHiddenFieldsSchema = z.union([
@@ -491,11 +890,10 @@ export const useParamStepsWithHiddenFieldsSchema = z.union([
 export const useParamObjectOfStepsWithHiddenFieldsSchema = z
     .object({
     steps: useParamStepsWithHiddenFieldsSchema,
-    bundle_steps: z.boolean().optional(),
-    group_by_original: z.boolean().optional(),
-    fields: z
-        .array(z.string())
-        .optional()
+    bundle_steps: optionalWithV3Semantics(z.boolean()),
+    group_by_original: optionalWithV3Semantics(z.boolean()),
+    fields: optionalWithV3Semantics(z
+        .array(z.string()))
         .describe(`
 Array of field names to filter input files by when using steps.
 `),
@@ -503,100 +901,27 @@ Array of field names to filter input files by when using steps.
     .strict();
 export const robotUse = z
     .object({
-    use: z
+    use: optionalWithV3Semantics(z
         .union([useParamStepsSchema, useParamObjectOfStepsSchema])
-        .describe(`
-Specifies which Step(s) to use as input.
-
-- You can pick any names for Steps except \`":original"\` (reserved for user uploads handled by Transloadit)
-- You can provide several Steps as input with arrays:
-  \`\`\`json
-  {
-    "use": [
-      ":original",
-      "encoded",
-      "resized"
-    ]
-  }
-  \`\`\`
-- You can also tag an input Step with \`as\` to pass semantic intent to robots:
-- You can also tag input Steps with \`as\` to pass semantic intent to robots:
-  \`\`\`json
-  {
-    "use": [
-      {
-        "name": ":original",
-        "as": "image"
-      },
-      {
-        "name": ":original",
-        "as": "mask"
-      }
-    ]
-  }
-  \`\`\`
-
-> [!Tip]
-> That's likely all you need to know about \`use\`, but you can view [Advanced use cases](/docs/topics/use-parameter/).
-`)
-        .optional(),
+        .describe(robotParameterDocs.use.description)),
 })
     .strict();
 export const robotUseWithHiddenFields = z
     .object({
-    use: z
+    use: optionalWithV3Semantics(z
         .union([useParamStepsWithHiddenFieldsSchema, useParamObjectOfStepsWithHiddenFieldsSchema])
-        .describe(`
-Specifies which Step(s) to use as input.
-
-- You can pick any names for Steps except \`":original"\` (reserved for user uploads handled by Transloadit)
-- You can provide several Steps as input with arrays:
-  \`\`\`json
-  {
-    "use": [
-      ":original",
-      "encoded",
-      "resized"
-    ]
-  }
-  \`\`\`
-- You can also tag an input Step with \`as\` to pass semantic intent to robots:
-- You can also tag input Steps with \`as\` to pass semantic intent to robots:
-  \`\`\`json
-  {
-    "use": [
-      {
-        "name": ":original",
-        "as": "image"
-      },
-      {
-        "name": ":original",
-        "as": "mask"
-      }
-    ]
-  }
-  \`\`\`
-
-> [!Tip]
-> That's likely all you need to know about \`use\`, but you can view [Advanced use cases](/docs/topics/use-parameter/).
-`)
-        .optional(),
+        .describe(robotParameterDocs.use.description)),
 })
     .strict();
-export const complexWidthSchema = z.preprocess((val) => {
-    if (typeof val === 'string' && val.startsWith('${')) {
-        return val;
-    }
-    if (typeof val === 'string') {
-        const num = Number.parseInt(val, 10);
-        if (Number.isNaN(num) || val.includes('x')) {
-            return val;
-        }
-        return num;
-    }
-    return val;
-}, z.number().int().min(1).max(25_000));
-export const complexHeightSchema = z.preprocess((val) => {
+const complexDimensionNumberSchema = z.number().int().min(1).max(25_000);
+const complexDimensionStringSchema = z
+    .string()
+    .regex(new RegExp(`^${ecmaWhitespaceCharacterClass}*\\+?0*(?:[1-9][0-9]{0,3}|1[0-9]{4}|2[0-4][0-9]{3}|25000)(?:[^0-9x][^x]*)?$`, 'u'));
+const complexDimensionInputSchema = z.union([
+    complexDimensionNumberSchema,
+    complexDimensionStringSchema,
+]);
+function normalizeComplexDimension(val) {
     if (typeof val === 'string' && val.startsWith('${')) {
         return val;
     }
@@ -608,126 +933,122 @@ export const complexHeightSchema = z.preprocess((val) => {
         return num;
     }
     return val;
-}, z.number().int().min(1).max(25_000));
+}
+export const complexWidthSchema = zodWithJsonInputSchema(z.preprocess(normalizeComplexDimension, complexDimensionNumberSchema), complexDimensionInputSchema);
+export const complexHeightSchema = zodWithJsonInputSchema(z.preprocess(normalizeComplexDimension, complexDimensionNumberSchema), complexDimensionInputSchema);
 export const robotFFmpeg = z.object({
-    ffmpeg: z
+    ffmpeg: optionalWithV3Semantics(z
         .object({
-        af: z.string().optional(),
-        'b:a': z.union([z.string(), z.number()]).optional(),
-        'b:v': z.union([z.string(), z.number()]).optional(),
-        'c:a': z.string().optional(),
-        'c:v': z.string().optional(),
-        'codec:a': z.string().optional(),
-        'codec:v': z.string().optional(),
-        'filter:v': z.string().optional(),
-        'filter:a': z.string().optional(),
-        bits_per_mb: z.union([z.string(), z.number()]).optional(),
-        ss: z.union([z.string(), z.number()]).optional(),
-        t: z.union([z.string(), z.number()]).optional(),
-        to: z.union([z.string(), z.number()]).optional(),
-        vendor: z.string().optional(),
+        af: optionalWithV3Semantics(z.string()),
+        'b:a': optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        'b:v': optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        'c:a': optionalWithV3Semantics(z.string()),
+        'c:v': optionalWithV3Semantics(z.string()),
+        'codec:a': optionalWithV3Semantics(z.string()),
+        'codec:v': optionalWithV3Semantics(z.string()),
+        'filter:v': optionalWithV3Semantics(z.string()),
+        'filter:a': optionalWithV3Semantics(z.string()),
+        bits_per_mb: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        ss: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        t: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        to: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        vendor: optionalWithV3Semantics(z.string()),
         shortest: z.boolean().nullish(),
-        filter_complex: z.union([z.string(), z.record(z.string(), z.string())]).optional(),
-        'level:v': z.union([z.string(), z.number()]).optional(),
-        'profile:v': z.union([z.number(), z.enum(['baseline', 'main', 'high', 'main10'])]).optional(),
-        'qscale:a': z.number().optional(),
-        'qscale:v': z.number().optional(),
-        'x264-params': z.string().optional(),
-        'overshoot-pct': z.number().optional(),
-        deadline: z.string().optional(),
-        'cpu-used': z.string().optional(),
-        'undershoot-pct': z.number().optional(),
-        'row-mt': z.number().optional(),
-        'x265-params': z
+        filter_complex: optionalWithV3Semantics(z.union([z.string(), z.record(z.string(), z.string())])),
+        'level:v': optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        'profile:v': optionalWithV3Semantics(z.union([z.number(), z.enum(['baseline', 'main', 'high', 'main10'])])),
+        'qscale:a': optionalWithV3Semantics(z.number()),
+        'qscale:v': optionalWithV3Semantics(z.number()),
+        'x264-params': optionalWithV3Semantics(z.string()),
+        'overshoot-pct': optionalWithV3Semantics(z.number()),
+        deadline: optionalWithV3Semantics(z.string()),
+        'cpu-used': optionalWithV3Semantics(z.string()),
+        'undershoot-pct': optionalWithV3Semantics(z.number()),
+        'row-mt': optionalWithV3Semantics(z.number()),
+        'x265-params': optionalWithV3Semantics(z
             .object({
-            'vbv-maxrate': z.number().optional(),
-            'vbv-bufsize': z.number().optional(),
-            'rc-lookahead': z.number().optional(),
-            'b-adapt': z.number().optional(),
+            'vbv-maxrate': optionalWithV3Semantics(z.number()),
+            'vbv-bufsize': optionalWithV3Semantics(z.number()),
+            'rc-lookahead': optionalWithV3Semantics(z.number()),
+            'b-adapt': optionalWithV3Semantics(z.number()),
         })
-            .strict()
-            .optional(),
-        'svtav1-params': z
+            .strict()),
+        'svtav1-params': optionalWithV3Semantics(z
             .object({
-            tune: z.number().optional(),
-            'enable-qm': z.number().optional(),
-            'fast-decode': z.number().optional(),
-            'film-grain-denoise': z.number().optional(),
+            tune: optionalWithV3Semantics(z.number()),
+            'enable-qm': optionalWithV3Semantics(z.number()),
+            'fast-decode': optionalWithV3Semantics(z.number()),
+            'film-grain-denoise': optionalWithV3Semantics(z.number()),
         })
-            .strict()
-            .optional(),
-        ac: z.number().optional(),
-        an: z.boolean().optional(),
-        ar: z.number().optional(),
-        async: z.number().optional(),
-        b: z
+            .strict()),
+        ac: optionalWithV3Semantics(z.number()),
+        an: optionalWithV3Semantics(z.boolean()),
+        ar: optionalWithV3Semantics(z.number()),
+        async: optionalWithV3Semantics(z.number()),
+        b: optionalWithV3Semantics(z
             .union([
             z
                 .object({
-                v: z.number().optional(),
-                a: z.number().optional(),
+                v: optionalWithV3Semantics(z.number()),
+                a: optionalWithV3Semantics(z.number()),
             })
                 .strict(),
             z.string(),
-        ])
-            .optional(),
-        bt: z.union([z.number(), z.string()]).optional(),
-        bufsize: z.union([z.string(), z.number()]).optional(),
-        c: z.string().optional(),
-        codec: z
+        ])),
+        bt: optionalWithV3Semantics(z.union([z.number(), z.string()])),
+        bufsize: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        c: optionalWithV3Semantics(z.string()),
+        codec: optionalWithV3Semantics(z
             .object({
-            v: z.string().optional(),
-            a: z.string().optional(),
+            v: optionalWithV3Semantics(z.string()),
+            a: optionalWithV3Semantics(z.string()),
         })
-            .strict()
-            .optional(),
-        coder: z.number().optional(),
-        crf: z.number().optional(),
-        f: z.string().optional(),
-        flags: z.string().optional(),
-        g: z.number().optional(),
-        i_qfactor: z.union([z.string(), z.number()]).optional(),
-        keyint_min: z.number().optional(),
-        level: z.union([z.string(), z.number()]).optional(),
-        map: z.union([z.string(), z.array(z.string())]).optional(),
-        maxrate: z.union([z.string(), z.number()]).optional(),
-        me_range: z.number().optional(),
-        movflags: z.string().optional(),
-        partitions: z.string().optional(),
-        pix_fmt: z.string().optional(),
-        preset: z.union([z.string(), z.number()]).optional(),
-        profile: z.string().optional(),
-        'q:a': z.number().optional(),
-        qcomp: z.union([z.string(), z.number()]).optional(),
-        qdiff: z.number().optional(),
-        qmax: z.number().optional(),
-        qmin: z.number().optional(),
-        r: z.union([z.number(), z.string()]).nullable().optional(),
-        rc_eq: z.string().optional(),
-        refs: z.number().optional(),
-        s: z.string().optional(),
-        sc_threshold: z.number().optional(),
-        sws_flags: z.string().optional(),
-        threads: z.number().optional(),
-        trellis: z.number().optional(),
-        transloaditffpreset: z.literal('empty').optional(),
-        vn: z.boolean().optional(),
-        vf: z.string().optional(),
-        x264opts: z.string().optional(),
-        vbr: z.union([z.string(), z.number()]).optional(),
+            .strict()),
+        coder: optionalWithV3Semantics(z.number()),
+        crf: optionalWithV3Semantics(z.number()),
+        f: optionalWithV3Semantics(z.string()),
+        flags: optionalWithV3Semantics(z.string()),
+        g: optionalWithV3Semantics(z.number()),
+        i_qfactor: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        keyint_min: optionalWithV3Semantics(z.number()),
+        level: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        map: optionalWithV3Semantics(z.union([z.string(), z.array(z.string())])),
+        maxrate: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        me_range: optionalWithV3Semantics(z.number()),
+        movflags: optionalWithV3Semantics(z.string()),
+        partitions: optionalWithV3Semantics(z.string()),
+        pix_fmt: optionalWithV3Semantics(z.string()),
+        preset: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        profile: optionalWithV3Semantics(z.string()),
+        'q:a': optionalWithV3Semantics(z.number()),
+        qcomp: optionalWithV3Semantics(z.union([z.string(), z.number()])),
+        qdiff: optionalWithV3Semantics(z.number()),
+        qmax: optionalWithV3Semantics(z.number()),
+        qmin: optionalWithV3Semantics(z.number()),
+        r: optionalWithV3Semantics(z.union([z.number(), z.string()]).nullable()),
+        rc_eq: optionalWithV3Semantics(z.string()),
+        refs: optionalWithV3Semantics(z.number()),
+        s: optionalWithV3Semantics(z.string()),
+        sc_threshold: optionalWithV3Semantics(z.number()),
+        sws_flags: optionalWithV3Semantics(z.string()),
+        threads: optionalWithV3Semantics(z.number()),
+        trellis: optionalWithV3Semantics(z.number()),
+        transloaditffpreset: optionalWithV3Semantics(z.literal('empty')),
+        vn: optionalWithV3Semantics(z.boolean()),
+        vf: optionalWithV3Semantics(z.string()),
+        x264opts: optionalWithV3Semantics(z.string()),
+        vbr: optionalWithV3Semantics(z.union([z.string(), z.number()])),
     })
-        .catchall(z.unknown())
-        .optional()
-        .describe(`
-A parameter object to be passed to FFmpeg. If a preset is used, the options specified are merged on top of the ones from the preset. For available options, see the [FFmpeg documentation](https://ffmpeg.org/ffmpeg-doc.html). Options specified here take precedence over the preset options.
-`),
+        .catchall(z.unknown()))
+        .describe(robotParameterDocs.ffmpeg.description),
     ffmpeg_stack: z
         // Any semver in range is allowed and normalized. The enum is used for editor completions.
-        .union([z.enum(['v6', 'v7', 'v8']), z.string().regex(/^v?[5-8](\.\d+)?(\.\d+)?$/)])
-        .default('v6.0.0')
-        .describe(`
-Selects the FFmpeg stack version to use for encoding. These versions reflect real FFmpeg versions. We currently recommend to use "v6.0.0". Deprecated "v5.x" values are accepted for backward compatibility.
-`),
+        .union([
+        z.enum(stackVersions.ffmpeg.suggestedValues),
+        z.string().regex(stackVersions.ffmpeg.test),
+    ])
+        .default(runtimeStackVersions.ffmpeg.default)
+        .describe(robotParameterDocs.ffmpeg_stack.description),
 });
 /**
  * Replace all underscores with hyphens.
@@ -803,43 +1124,15 @@ const audioPresets = createPresets([
 ]);
 export const robotFFmpegAudio = robotFFmpeg
     .extend({
-    preset: z
-        .enum(audioPresets)
-        .transform(transformPreset)
-        .optional()
-        .describe(`
-Performs conversion using pre-configured settings.
-
-If you specify your own FFmpeg parameters using the <dfn>Robot</dfn>'s \`ffmpeg\` parameter and you have not specified a preset, then the default \`mp3\` preset is not applied. This is to prevent you from having to override each of the MP3 preset's values manually.
-
-For a list of audio presets, see [audio presets](/docs/presets/audio/).
-`),
+    preset: optionalWithV3Semantics(zodInputPreservingTransform(z.enum(audioPresets), transformPreset))
+        .describe(robotParameterDocs.audio_preset.description),
 })
     .strict();
 export const robotFFmpegVideo = robotFFmpeg
     .extend({
-    width: z
-        .number()
-        .int()
-        .min(1)
-        .nullish()
-        .describe(`
-Width of the new video, in pixels.
-
-If the value is not specified and the \`preset\` parameter is available, the \`preset\`'s [supplied width](/docs/presets/video/) will be implemented.
-`),
-    height: z
-        .number()
-        .int()
-        .min(1)
-        .nullish()
-        .describe(`
-Height of the new video, in pixels.
-
-If the value is not specified and the \`preset\` parameter is available, the \`preset\`'s [supplied height](/docs/presets/video/) will be implemented.
-`),
-    preset: z
-        .enum([
+    width: z.number().int().min(1).nullish().describe(robotParameterDocs.video_width.description),
+    height: z.number().int().min(1).nullish().describe(robotParameterDocs.video_height.description),
+    preset: optionalWithV3Semantics(zodInputPreservingTransform(z.enum([
         ...createPresets([
             'android',
             'android-high',
@@ -934,14 +1227,8 @@ If the value is not specified and the \`preset\` parameter is available, the \`p
             'wmv',
         ]),
         ...audioPresets,
-    ])
-        .transform(transformPreset)
-        .optional()
-        .describe(`
-Converts a video according to [pre-configured settings](/docs/presets/video/).
-
-If you specify your own FFmpeg parameters using the <dfn>Robot</dfn>'s and/or do not not want Transloadit to set any encoding setting, starting \`ffmpeg_stack: "${stackVersions.ffmpeg.recommendedVersion}"\`,  you can use the value \`'empty'\` here.
-`),
+    ]), transformPreset))
+        .describe(robotParameterDocs.video_preset.description),
 })
     .strict();
 export const unsafeCoordinatesSchema = z
@@ -972,11 +1259,63 @@ export const next_page_token = z.string().default('');
 export const files_per_page = z.number().int().default(1000);
 export const page_number = z.number().int().default(1);
 export const recursive = z.boolean().default(false);
+export const bucketImportPath = 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>.
+`);
+export const storeFilePath = 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.
+`);
+export const recursiveImportPageNumber = 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.
+`);
+export const signedSslUrlLifetime = optionalWithV3Semantics(z
+    .number()
+    .int()
+    .min(0))
+    .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.
+`);
+export const recursiveImportPageSize = 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.
+`);
+const bucketRegion = optionalWithV3Semantics(z
+    .string())
+    .describe(`
+The region where the bucket is located.
+`);
+export const storePath = 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).
+`);
+export const storageAcl = z
+    .enum(['private', 'public-read'])
+    .default('public-read')
+    .describe(`
+The permissions used for this file.
+`);
+export const recursiveImport = recursive.describe(`
+Setting this to \`true\` will enable importing files from subdirectories and sub-subdirectories (etc.) of the given path.
+
+Please use the pagination parameters \`page_number\` and \`files_per_page\` wisely here.
+`);
 export const return_file_stubs = z
     .boolean()
-    .describe(`
-If set to \`true\`, the Robot will not yet import the actual files but instead return an empty file stub that includes a URL from where the file can be imported by subsequent Robots. This is useful for cases where subsequent Steps need more control over the import process, such as with 🤖/video/ondemand. This parameter should only be set if all subsequent Steps use Robots that support file stubs.
-`)
+    .describe(robotParameterDocs.return_file_stubs.description)
     .default(false);
 export const port = z.number().int().min(1).max(65535);
 // TODO: Use an enum.
@@ -995,13 +1334,24 @@ export const positionSchema = z.enum([
     'top-left',
     'top-right',
 ]);
-export const percentageSchema = z.string().regex(/^\d+%$/);
-export const httpUrlSchema = z
+export const percentageSchema = z.string().regex(/^[0-9]+%$/u);
+const portableHttpUrlPattern = /^[Hh][Tt][Tt][Pp][Ss]?:\/\/(?:[^ ]|[ ])/u;
+const portableHttpUrlInputSchema = z
+    .string()
+    .regex(portableHttpUrlPattern, 'Must be an HTTP or HTTPS URL');
+export const httpUrlSchema = zodWithConservativeJsonInputSchema(z
     .string()
     .url()
-    .regex(/^https?:\/\//i);
-export const color_with_alpha = z.string().regex(/^#?[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/);
-export const color_without_alpha = z.string().regex(/^#?[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/);
+    .refine((value) => /^https?:\/\//iu.test(value), 'Must be an HTTP or HTTPS URL'), portableHttpUrlInputSchema);
+/** Header restrictions shared by HTTP import and request documentation. */
+export const httpHeaderSafetyDescription = `Header names must be valid HTTP tokens. Header values may contain horizontal tabs, but other control characters, including carriage returns and line feeds, are rejected.
+
+In an array of header strings, \`"Header-Name;"\` sends an empty header value. Each entry must be a literal header; reading headers from a file with \`@filename\` is not supported.`;
+export const color_with_alpha = z.string().regex(/^#?[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/u);
+export const color_without_alpha = z.string().regex(/^#?[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/u);
+export const videoBackgroundSchema = color_with_alpha
+    .default('#00000000')
+    .describe(robotParameterDocs.video_background.description);
 // Extended color schemas that also support named colors (for robots that support them)
 export const color_with_alpha_with_named = z.union([
     color_with_alpha, // Extend the base hex color schema
@@ -1041,15 +1391,16 @@ export const color_without_alpha_with_named = z.union([
 ]);
 export const bitrateSchema = z.number().int().min(1);
 export const sampleRateSchema = z.number().int().min(1);
-export const optimize_priority = z
-    .enum(['compression-ratio', 'conversion-speed'])
-    .default('conversion-speed');
+export const optimize_priority = z.enum(['compression-ratio', 'conversion-speed']);
 export const robotImagemagick = z
     .object({
     imagemagick_stack: z
         // Any semver in range is allowed and normalized. The enum is used for editor completions.
-        .union([z.enum(['v3']), z.string().regex(/^v?[23](\.\d+)?(\.\d+)?$/)])
-        .default('v3'),
+        .union([
+        z.enum([stackVersions.imagemagick.recommendedVersion]),
+        z.string().regex(stackVersions.imagemagick.test),
+    ])
+        .default(runtimeStackVersions.imagemagick.default),
 })
     .strict();
 export const colorspaceSchema = z.enum([
@@ -1089,17 +1440,15 @@ export const colorspaceSchema = z.enum([
     'YPbPr',
     'YUV',
 ]);
+export const imageAdaptiveFilteringSchema = z
+    .boolean()
+    .default(false)
+    .describe(robotParameterDocs.adaptive_filtering.description);
+export const imageQualityValueSchema = z.number().int().min(1).max(100);
 // TODO: add before and after images to the description.
-export const imageQualitySchema = z
-    .number()
-    .int()
-    .min(1)
-    .max(100)
-    .default(92)
-    .describe(`
+export const imageQualitySchema = imageQualityValueSchema.default(92).describe(`
 Controls the image compression for JPG and PNG images. Please also take a look at [🤖/image/optimize](/docs/robots/image-optimize/).
 `);
-export const autoProviderDescription = 'Chooses the best provider based on your request';
 export const awsGcpAiProviderSchema = z.enum(['auto', 'aws', 'gcp']).default('auto');
 export const aiProviderSchema = z
     .enum(['auto', 'aws', 'gcp', 'replicate', 'fal', 'transloadit'])
@@ -1111,39 +1460,34 @@ export const robotImport = z
         .union([z.string(), z.array(z.string())])
         .nullable()
         .default(null)
-        .describe('Custom name for the imported file(s). By default file names are derived from the source.'),
-    ignore_errors: z
-        .union([z.boolean(), z.array(z.enum(['meta', 'import', 'execute']))])
-        .transform((value) => value === true ? ['meta', 'import', 'execute'] : value === false ? [] : value)
-        .default([]),
+        .describe(robotParameterDocs.force_name.description),
+    ignore_errors: zodInputPreservingTransform(z.union([z.boolean(), z.array(z.enum(['meta', 'import', 'execute']))]), (value) => (value === true ? ['meta', 'import', 'execute'] : value === false ? [] : value))
+        .default([])
+        .describe(robotParameterDocs.import_ignore_errors.description),
     import_on_errors: z
         .array(z.enum(['meta']))
         .default([])
-        .describe(`
-Setting this to \`["meta"]\` will still import the file on metadata extraction errors. \`ignore_errors\` is similar, it also ignores the error and makes sure the Robot doesn't stop, but it doesn't import the file.
-`),
+        .describe(robotParameterDocs.import_on_errors.description),
 })
     .strict();
 export const azureBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your [Template Credentials](/c/template-credentials/) as this parameter's value. They will contain the values for your Azure Container, Account and Key.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"account"\`, \`"key"\`, \`"container"\`.
 `),
-    account: z.string().optional(),
-    container: z.string().optional(),
-    key: z.string().optional(),
+    account: optionalWithV3Semantics(z.string()),
+    container: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const backblazeBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Backblaze Bucket Name, App Key ID, and App Key.
 
@@ -1155,16 +1499,15 @@ Now that everything is in place, create your key, and take note of the informati
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"app_key_id"\`, \`"app_key"\`.
 `),
-    bucket: z.string().optional(),
-    app_key_id: z.string().optional(),
-    app_key: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    app_key_id: optionalWithV3Semantics(z.string()),
+    app_key: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const boxBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Create a Box app in the [Box Developer Console](https://app.box.com/developers/console) using **Server Authentication (JWT)**.
 
@@ -1178,58 +1521,54 @@ If your Box enterprise requires it, make sure the app is authorized by an admin
     .strict();
 export const cloudfilesBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your [Template Credentials](/c/template-credentials/) as this parameter's value. They will contain the values for your Cloud Files Container, User, Key, Account type and Data center.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"account_type"\` ("us" or "uk"), \`"data_center"\` ("dfw" for Dallas or "ord" for Chicago for example), \`"user"\`, \`"key"\`, \`"container"\`.
 `),
-    account_type: z.enum(['uk', 'us']).optional(),
-    data_center: z.string().optional(),
-    user: z.string().optional(),
-    key: z.string().optional(),
-    container: z.string().optional(),
+    account_type: optionalWithV3Semantics(z.enum(['uk', 'us'])),
+    data_center: optionalWithV3Semantics(z.string()),
+    user: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    container: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const cloudflareBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
-Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your cloudflare bucket, Key, Secret and Bucket region.
+Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Cloudflare R2 bucket, Key, Secret and Bucket region.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"host"\`, \`"key"\`, \`"secret"\`.
 `),
-    bucket: z.string().optional(),
-    host: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    host: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const digitalOceanBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your [Template Credentials](/c/template-credentials/) as this parameter's value. They will contain the values for your DigitalOcean Space, Key, Secret and Region.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"space"\`, \`"region"\` (for example: \`"fra1"\` or \`"nyc3"\`), \`"key"\`, \`"secret"\`.
 `),
-    space: z.string().optional(),
-    region: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    space: optionalWithV3Semantics(z.string()),
+    region: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const dropboxBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Dropbox access token.
 `),
@@ -1237,9 +1576,8 @@ Please create your associated <dfn>Template Credentials</dfn> in your Transloadi
     .strict();
 export const vimeoBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Vimeo access token.
 `),
@@ -1247,25 +1585,23 @@ Please create your associated <dfn>Template Credentials</dfn> in your Transloadi
     .strict();
 export const ftpBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your FTP host, user and password.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> with their static nature is too unwieldy. If you have this requirement, feel free to use the following parameters instead: \`"host"\`, \`"user"\`, \`"password"\`.
 `),
-    host: z.string().optional(),
+    host: optionalWithV3Semantics(z.string()),
     port: port.default(21).describe('The port to use for the FTP connection.'),
-    user: z.string().optional(),
-    password: z.string().optional(),
+    user: optionalWithV3Semantics(z.string()),
+    password: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const googleBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Create a new [Google service account](https://cloud.google.com/storage/docs/authentication). Set its role to "Storage Object Creator". Choose "JSON" for the key file format and download it to your computer. You will need to upload this file when creating your <dfn>Template Credentials</dfn>.
 
@@ -1283,79 +1619,69 @@ Then, create your associated [Template Credentials](/c/template-credentials/) in
     .strict();
 export const minioBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your MinIO bucket, Key, Secret and Bucket region.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"host"\`, \`"key"\`, \`"secret"\`.
 `),
-    bucket: z.string().optional(),
-    host: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    host: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const megaBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
-Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your MEGA object storage bucket, Key, Secret and Bucket region.
+Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your MEGA S4 Object Storage bucket, Key, Secret and Bucket region.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"bucket_region"\`, \`"key"\`, \`"secret"\`.
 `),
-    bucket: z.string().optional(),
-    bucket_region: z
-        .string()
-        .optional()
-        .describe(`
-The region where the bucket is located.
-`),
-    host: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    bucket_region: bucketRegion,
+    host: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const s3Base = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
-Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your S3 bucket, Key, Secret and Bucket region.
+Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your S3 \`bucket\`, \`key\`, \`secret\` and \`bucket_region\`.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"bucket_region"\` (for example: \`"us-east-1"\` or \`"eu-west-2"\`), \`"key"\`, \`"secret"\`.
 `),
-    bucket: z.string().optional(),
-    bucket_region: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    bucket_region: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const sftpBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your SFTP host, user and optional custom public key.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"host"\`, \`"port"\`, \`"user"\`, \`"public_key"\` (optional).
 `),
-    host: z.string().optional(),
+    host: optionalWithV3Semantics(z.string()),
     port: port.default(21).describe('The port to use for the FTP connection.'),
-    user: z.string().optional(),
-    public_key: z.string().optional(),
+    user: optionalWithV3Semantics(z.string()),
+    public_key: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const supabaseBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Supabase bucket, Key, Secret and Bucket region.
 
@@ -1363,82 +1689,62 @@ While we recommend to use <dfn>Template Credentials</dfn> at all times, some use
 
 If you do use these parameters, make sure to use the **Endpoint** value under \`Storage > S3 Connection\` in the Supabase console for the \`"host"\` value, and the values under **S3 Access Keys** on the same page for your \`"key"\` and \`"secret"\`.
 `),
-    bucket: z.string().optional(),
-    bucket_region: z
-        .string()
-        .optional()
-        .describe(`
-The region where the bucket is located.
-`),
-    host: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    bucket_region: bucketRegion,
+    host: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const swiftBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
-  Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Swift bucket, Key, Secret and Bucket region.
+  Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your OpenStack Swift container (provided through the \`"bucket"\` parameter), host, Key and Secret.
 
   While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"host"\`, \`"key"\`, \`"secret"\`.
   `),
-    bucket: z.string().optional(),
-    bucket_region: z
-        .string()
-        .optional()
+    bucket: optionalWithV3Semantics(z.string()),
+    host: optionalWithV3Semantics(z
+        .string())
         .describe(`
-The region where the bucket is located.
+The S3-compatible object storage endpoint for the OpenStack Swift service. This is required when supplying dynamic credentials directly instead of using Template Credentials.
 `),
-    host: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const tigrisBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
-Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your MinIO bucket, Key, Secret and Bucket region.
+Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Tigris bucket, Key, Secret and Bucket region.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"host"\`, \`"key"\`, \`"secret"\`.
 `),
-    bucket: z.string().optional(),
-    bucket_region: z
-        .string()
-        .optional()
-        .describe(`
-The region where the bucket is located.
-`),
-    host: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    bucket_region: bucketRegion,
+    host: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const wasabiBase = z
     .object({
-    credentials: z
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your Wasabi bucket, Key, Secret and Bucket region.
 
 While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"host"\`, \`"key"\`, \`"secret"\`.
 `),
-    bucket: z.string().optional(),
-    bucket_region: z
-        .string()
-        .optional()
-        .describe(`
-The region where the bucket is located.
-`),
-    host: z.string().optional(),
-    key: z.string().optional(),
-    secret: z.string().optional(),
+    bucket: optionalWithV3Semantics(z.string()),
+    bucket_region: bucketRegion,
+    host: optionalWithV3Semantics(z.string()),
+    key: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.string()),
 })
     .strict();
 export const filterExpression = z.union([
@@ -1496,7 +1802,7 @@ See the [available resize strategies](/docs/topics/resize-strategies/).
         .describe(`
 If this is set to \`false\`, smaller videos will not be stretched to the desired width and height. For details about the impact of zooming for your preferred resize strategy, see the list of available [resize strategies](/docs/topics/resize-strategies/).
 `),
-    crop: unsafeCoordinatesSchema.optional().describe(`
+    crop: optionalWithV3Semantics(unsafeCoordinatesSchema).describe(`
 Specify an object containing coordinates for the top left and bottom right corners of the rectangle to be cropped from the original video(s). Values can be integers for absolute pixel values or strings for percentage based values.
 
 For example:
@@ -1518,10 +1824,8 @@ You can also use a JSON string of such an object with coordinates in similar fas
 "{\\"x1\\": <Integer>, \\"y1\\": <Integer>, \\"x2\\": <Integer>, \\"y2\\": <Integer>}"
 \`\`\`
 `),
-    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.
-`),
-    rotate: z
+    background: videoBackgroundSchema,
+    rotate: optionalWithV3Semantics(z
         // We can’t use enum.
         // See https://github.com/colinhacks/zod/issues/2686
         .union([
@@ -1531,8 +1835,7 @@ The background color of the resulting video the \`"rrggbbaa"\` format (red, gree
         z.literal(270),
         z.literal(360),
         z.literal(false),
-    ])
-        .optional()
+    ]))
         .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. If you set \`rotate\` to \`false\` no rotation is performed, even if the metadata contains such instructions.
 `),
@@ -1548,11 +1851,10 @@ Enables hinting for mp4 files, for RTP/RTSP streaming.
         .describe(`
 Splits the video into multiple chunks so that each chunk can be encoded in parallel before all encoded chunks are stitched back together to form the result video. This comes at the expense of extra <dfn>Priority Job Slots</dfn> and may prove to be counter-productive for very small video files.
 `),
-    chunk_duration: z
+    chunk_duration: optionalWithV3Semantics(z
         .number()
         .int()
-        .min(1)
-        .optional()
+        .min(1))
         .describe(`
 Allows you to specify the duration of each chunk when \`turbo\` is set to \`true\`. This means you can take advantage of that feature while using fewer <dfn>Priority Job Slots</dfn>. For instance, the longer each chunk is, the fewer <dfn>Encoding Jobs</dfn> will need to be used.
 `),
@@ -1590,7 +1892,7 @@ The y-offset in number of pixels at which the watermark will be placed in relati
 
 Values can be both positive and negative and yield different results depending on the \`watermark_position\` parameter. Positive values move the watermark closer to the image's center point, whereas negative values move the watermark further away from the image's center point.
 `),
-    watermark_size: percentageSchema.optional().describe(`
+    watermark_size: optionalWithV3Semantics(percentageSchema).describe(`
 The size of the watermark, as a percentage, such as \`"50%"\`. How the watermark is resized greatly depends on the \`watermark_resize_strategy\`.
 `),
     watermark_resize_strategy: z
@@ -1651,9 +1953,8 @@ The prefix used for the naming. For example, a prefix of \`"segment_"\` would pr
         .describe(`
 The name used for the final segment. Available variables are \`\${segment_prefix}\`, \`\${segment_number}\` and \`\${segment_id}\` (which is a UUIDv4 without dashes).
 `),
-    segment_time_delta: z
-        .number()
-        .optional()
+    segment_time_delta: optionalWithV3Semantics(z
+        .number())
         .describe(`
 Delta to apply to segment duration. This is optional and allows fine-tuning of segment boundaries.
 `),