@transloadit/zod 4.4.1 → 5.0.0

package/dist/v4/robots/audio-loop.js

@@ -1,56 +1,31 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
 import { stackVersions } from "../stackVersions.js";
-import { bitrateSchema, interpolateRobot, robotBase, robotFFmpegAudio, robotUse, sampleRateSchema, } from "./_instructions-primitives.js";
+import { bitrateSchema, createProcessingExample, defineRobot, robotAudioEncodingMeta, robotBase, robotFFmpegAudio, robotParameterDocs, robotUse, sampleRateSchema, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 4,
-    discount_factor: 0.25,
-    discount_pct: 75,
-    example_code: {
-        steps: {
-            looped: {
-                robot: '/audio/loop',
-                use: ':original',
-                duration: 300,
-                ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
-            },
-        },
-    },
+    ...robotAudioEncodingMeta,
+    example_code: createProcessingExample('looped', '/audio/loop', {
+        duration: 300,
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+    }),
     example_code_description: 'Loop uploaded audio to achieve a target duration of 300 seconds:',
     marketing_intro: 'Whether you’re producing beats, white-noise, or just empty segments as fillers between audio tracks that you’re to stringing together with [🤖/audio/concat](/docs/robots/audio-concat/), [🤖/audio/loop](/docs/robots/audio-loop/) has got your back.',
-    minimum_charge: 0,
-    output_factor: 0.8,
-    override_lvl1: 'Audio Encoding',
     purpose_sentence: 'loops one audio file as often as is required to match a given duration',
     purpose_verb: 'loop',
     purpose_word: 'loop',
     purpose_words: 'Loop audio',
-    service_slug: 'audio-encoding',
-    slot_count: 20,
     title: 'Loop audio',
-    typical_file_size_mb: 3.8,
-    typical_file_type: 'audio file',
     uses_tools: ['ffmpeg'],
     name: 'AudioLoopRobot',
-    priceFactor: 4,
-    queueSlotCount: 20,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    applyCommunityPlanMediaTrim: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotAudioLoopInstructionsSchema = robotBase
     .merge(robotUse)
     .merge(robotFFmpegAudio)
     .extend({
     robot: z.literal('/audio/loop'),
-    bitrate: bitrateSchema.optional().describe(`
-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.
-`),
-    sample_rate: sampleRateSchema.optional().describe(`
-Sample rate of the resulting audio file, in Hertz. If not specified will default to the sample rate of the input audio file.
-`),
+    bitrate: optionalWithV3Semantics(bitrateSchema).describe(robotParameterDocs.audio_bitrate.description),
+    sample_rate: optionalWithV3Semantics(sampleRateSchema)
+        .describe(robotParameterDocs.audio_sample_rate.description),
     duration: z
         .number()
         .default(60)
@@ -59,8 +34,5 @@ Target duration for the whole process in seconds. The <dfn>Robot</dfn> will loop
 `),
 })
     .strict();
-export const robotAudioLoopInstructionsWithHiddenFieldsSchema = robotAudioLoopInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotAudioLoopInstructionsSchema.shape.result]).optional(),
-});
-export const interpolatableRobotAudioLoopInstructionsSchema = interpolateRobot(robotAudioLoopInstructionsSchema);
-export const interpolatableRobotAudioLoopInstructionsWithHiddenFieldsSchema = interpolateRobot(robotAudioLoopInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotAudioLoopInstructionsSchema);
+export const { withHiddenFields: robotAudioLoopInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotAudioLoopInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotAudioLoopInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/audio-merge.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotAudioMergeInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -52,8 +53,8 @@ export declare const robotAudioMergeInstructionsSchema: z.ZodObject<{
         filter_complex: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>>;
@@ -216,8 +217,8 @@ export declare const robotAudioMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
         filter_complex: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>>;
@@ -291,15 +292,16 @@ export declare const robotAudioMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
         x264opts: z.ZodOptional<z.ZodString>;
         vbr: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     }, z.core.$catchall<z.ZodUnknown>>>;
+    robot: z.ZodLiteral<"/audio/merge">;
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
-    robot: z.ZodLiteral<"/audio/merge">;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -385,19 +387,20 @@ export type RobotAudioMergeInstructions = z.infer<typeof robotAudioMergeInstruct
 export type RobotAudioMergeInstructionsWithHiddenFields = z.infer<typeof robotAudioMergeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotAudioMergeInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -434,8 +437,8 @@ export declare const interpolatableRobotAudioMergeInstructionsSchema: z.ZodObjec
         filter_complex: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodUnion<[z.ZodString, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>]>>;
@@ -509,7 +512,7 @@ export declare const interpolatableRobotAudioMergeInstructionsSchema: z.ZodObjec
         x264opts: z.ZodOptional<z.ZodString>;
         vbr: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
     }, z.core.$catchall<z.ZodUnknown>>]>>;
-    ffmpeg_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    ffmpeg_stack: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         v6: "v6";
         v7: "v7";
         v8: "v8";
@@ -561,13 +564,13 @@ export declare const interpolatableRobotAudioMergeInstructionsSchema: z.ZodObjec
     robot: z.ZodLiteral<"/audio/merge">;
     bitrate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     sample_rate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    duration: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    duration: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         shortest: "shortest";
         first: "first";
         longest: "longest";
     }>]>>;
-    loop: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    volume: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    loop: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    volume: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         average: "average";
         sum: "sum";
     }>]>>;
@@ -575,12 +578,12 @@ export declare const interpolatableRobotAudioMergeInstructionsSchema: z.ZodObjec
 export type InterpolatableRobotAudioMergeInstructions = InterpolatableRobotAudioMergeInstructionsInput;
 export type InterpolatableRobotAudioMergeInstructionsInput = z.input<typeof interpolatableRobotAudioMergeInstructionsSchema>;
 export declare const interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    duration: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    duration: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         shortest: "shortest";
         first: "first";
         longest: "longest";
     }>]>>;
-    loop: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    loop: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     ffmpeg: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
         af: z.ZodOptional<z.ZodString>;
         'b:a': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
@@ -600,8 +603,8 @@ export declare const interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSc
         filter_complex: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodUnion<[z.ZodString, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>]>>;
@@ -675,20 +678,21 @@ export declare const interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSc
         x264opts: z.ZodOptional<z.ZodString>;
         vbr: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
     }, z.core.$catchall<z.ZodUnknown>>]>>;
+    robot: z.ZodLiteral<"/audio/merge">;
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
-    robot: z.ZodLiteral<"/audio/merge">;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -736,14 +740,14 @@ export declare const interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSc
         "hg_transformers-audio": "hg_transformers-audio";
         hg_transformers_audio: "hg_transformers_audio";
     }>, z.ZodTransform<"empty" | "aac" | "alac" | "audio/aac" | "audio/alac" | "audio/flac" | "audio/mp3" | "audio/ogg" | "dash-32k-audio" | "dash-64k-audio" | "dash-128k-audio" | "dash-256k-audio" | "dash/32k-audio" | "dash/64k-audio" | "dash/128k-audio" | "dash/256k-audio" | "flac" | "hg-transformers-audio" | "mp3" | "ogg" | "opus" | "speech" | "wav", "empty" | "aac" | "alac" | "audio/aac" | "audio/alac" | "audio/flac" | "audio/mp3" | "audio/ogg" | "dash-32k-audio" | "dash-64k-audio" | "dash-128k-audio" | "dash-256k-audio" | "dash/32k-audio" | "dash/64k-audio" | "dash/128k-audio" | "dash/256k-audio" | "flac" | "hg-transformers-audio" | "mp3" | "ogg" | "opus" | "speech" | "wav" | "dash-32k_audio" | "dash_32k-audio" | "dash_32k_audio" | "dash-64k_audio" | "dash_64k-audio" | "dash_64k_audio" | "dash-128k_audio" | "dash_128k-audio" | "dash_128k_audio" | "dash-256k_audio" | "dash_256k-audio" | "dash_256k_audio" | "dash/32k_audio" | "dash/64k_audio" | "dash/128k_audio" | "dash/256k_audio" | "hg-transformers_audio" | "hg_transformers-audio" | "hg_transformers_audio">>]>>;
-    ffmpeg_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    ffmpeg_stack: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         v6: "v6";
         v7: "v7";
         v8: "v8";
     }>]>, z.ZodString]>>;
     bitrate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     sample_rate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    volume: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    volume: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         average: "average";
         sum: "sum";
     }>]>>;
@@ -763,8 +767,9 @@ export declare const interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSc
         group_by_original: z.ZodOptional<z.ZodBoolean>;
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotAudioMergeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSchema>;
 export type InterpolatableRobotAudioMergeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSchema>;
+export declare const robotDefinition: RobotSchemaPair<typeof interpolatableRobotAudioMergeInstructionsSchema, typeof interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSchema>;
 //# sourceMappingURL=audio-merge.d.ts.map

package/dist/v4/robots/audio-merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/audio-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAa1B,eAAO,MAAM,IAAI,EAAE,cAwDlB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8BnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"audio-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/audio-merge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAEpF,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAe1B,eAAO,MAAM,IAAI,EAAE,cAuClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2BnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,+CAA+C,EACtD,OAAO,+DAA+D,CAKvE,CAAA"}

package/dist/v4/robots/audio-merge.js

@@ -1,10 +1,9 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
 import { stackVersions } from "../stackVersions.js";
-import { bitrateSchema, interpolateRobot, robotBase, robotFFmpegAudio, robotUse, robotUseWithHiddenFields, sampleRateSchema, } from "./_instructions-primitives.js";
+import { bitrateSchema, interpolateRobot, robotAudioEncodingMeta, robotBase, robotFFmpegAudio, robotParameterDocs, robotUse, robotUseWithHiddenFields, sampleRateSchema, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 4,
-    discount_factor: 0.25,
-    discount_pct: 75,
+    ...robotAudioEncodingMeta,
     example_code: {
         steps: {
             merged: {
@@ -34,40 +33,22 @@ export const meta = {
         },
     },
     example_code_description: 'If you have a form with 3 file input fields and wish to overlay the uploaded audios, instruct Transloadit using the `name` attribute of each input field. Use this attribute as the value for the `fields` key in the JSON, and set `as` to `audio`:',
-    minimum_charge: 0,
-    output_factor: 0.8,
-    override_lvl1: 'Audio Encoding',
     purpose_sentence: 'overlays several audio files on top of each other',
     purpose_verb: 'merge',
     purpose_word: 'merge',
     purpose_words: 'Merge audio files into one',
-    service_slug: 'audio-encoding',
-    slot_count: 20,
     title: 'Merge audio files into one',
-    typical_file_size_mb: 3.8,
-    typical_file_type: 'audio file',
     uses_tools: ['ffmpeg'],
     name: 'AudioMergeRobot',
-    priceFactor: 4,
-    queueSlotCount: 20,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    applyCommunityPlanMediaTrim: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotAudioMergeInstructionsSchema = robotBase
     .merge(robotUse)
     .merge(robotFFmpegAudio)
     .extend({
     robot: z.literal('/audio/merge'),
-    bitrate: bitrateSchema.optional().describe(`
-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.
-`),
-    sample_rate: sampleRateSchema.optional().describe(`
-Sample rate of the resulting audio file, in Hertz. If not specified will default to the sample rate of the input audio file.
-`),
+    bitrate: optionalWithV3Semantics(bitrateSchema).describe(robotParameterDocs.audio_bitrate.description),
+    sample_rate: optionalWithV3Semantics(sampleRateSchema)
+        .describe(robotParameterDocs.audio_sample_rate.description),
     duration: z
         .enum(['first', 'longest', 'shortest'])
         .default('longest')
@@ -92,9 +73,13 @@ export const robotAudioMergeInstructionsWithHiddenFieldsSchema = robotAudioMerge
     .omit({ use: true })
     .merge(robotUseWithHiddenFields)
     .extend({
-    result: z
-        .union([z.literal('debug'), robotAudioMergeInstructionsSchema.shape.result])
-        .optional(),
+    result: optionalWithV3Semantics(z
+        .union([z.literal('debug'), robotAudioMergeInstructionsSchema.shape.result])),
 });
 export const interpolatableRobotAudioMergeInstructionsSchema = interpolateRobot(robotAudioMergeInstructionsSchema);
 export const interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotAudioMergeInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = {
+    meta,
+    interpolatable: interpolatableRobotAudioMergeInstructionsSchema,
+    interpolatableWithHiddenFields: interpolatableRobotAudioMergeInstructionsWithHiddenFieldsSchema,
+};

package/dist/v4/robots/audio-split.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotAudioSplitInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -51,8 +52,8 @@ export declare const robotAudioSplitInstructionsSchema: z.ZodObject<{
         filter_complex: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>>;
@@ -184,15 +185,17 @@ export declare const robotAudioSplitInstructionsSchema: z.ZodObject<{
     bitrate: z.ZodOptional<z.ZodNumber>;
     sample_rate: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotAudioSplitInstructionsSchema.shape>;
 export declare const robotAudioSplitInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -234,8 +237,8 @@ export declare const robotAudioSplitInstructionsWithHiddenFieldsSchema: z.ZodObj
         filter_complex: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>>;
@@ -366,23 +369,21 @@ export declare const robotAudioSplitInstructionsWithHiddenFieldsSchema: z.ZodObj
     bitrate: z.ZodOptional<z.ZodNumber>;
     sample_rate: z.ZodOptional<z.ZodNumber>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodOptional<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotAudioSplitInstructions = z.infer<typeof robotAudioSplitInstructionsSchema>;
-export type RobotAudioSplitInstructionsWithHiddenFields = z.infer<typeof robotAudioSplitInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotAudioSplitInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotAudioSplitInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -419,8 +420,8 @@ export declare const interpolatableRobotAudioSplitInstructionsSchema: z.ZodObjec
         filter_complex: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodUnion<[z.ZodString, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>]>>;
@@ -494,7 +495,7 @@ export declare const interpolatableRobotAudioSplitInstructionsSchema: z.ZodObjec
         x264opts: z.ZodOptional<z.ZodString>;
         vbr: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
     }, z.core.$catchall<z.ZodUnknown>>]>>;
-    ffmpeg_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    ffmpeg_stack: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         v6: "v6";
         v7: "v7";
         v8: "v8";
@@ -551,23 +552,21 @@ export declare const interpolatableRobotAudioSplitInstructionsSchema: z.ZodObjec
     }, z.core.$strict>]>>]>;
     bitrate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     sample_rate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotAudioSplitInstructions = InterpolatableRobotAudioSplitInstructionsInput;
-export type InterpolatableRobotAudioSplitInstructionsInput = z.input<typeof interpolatableRobotAudioSplitInstructionsSchema>;
-export declare const interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -604,8 +603,8 @@ export declare const interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSc
         filter_complex: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         'level:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
         'profile:v': z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodUnion<[z.ZodString, z.ZodEnum<{
-            main: "main";
             baseline: "baseline";
+            main: "main";
             high: "high";
             main10: "main10";
         }>]>]>>;
@@ -679,7 +678,7 @@ export declare const interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSc
         x264opts: z.ZodOptional<z.ZodString>;
         vbr: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
     }, z.core.$catchall<z.ZodUnknown>>]>>;
-    ffmpeg_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    ffmpeg_stack: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         v6: "v6";
         v7: "v7";
         v8: "v8";
@@ -737,6 +736,12 @@ export declare const interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSc
     sample_rate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotAudioSplitInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotAudioSplitInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotAudioSplitInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotAudioSplitInstructions = Instructions['output'];
+export type RobotAudioSplitInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotAudioSplitInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotAudioSplitInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotAudioSplitInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotAudioSplitInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=audio-split.d.ts.map

package/dist/v4/robots/audio-split.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio-split.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/audio-split.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAY1B,eAAO,MAAM,IAAI,EAAE,cA0ClB,CAAA;AAiBD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"audio-split.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/audio-split.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAe1B,eAAO,MAAM,IAAI,EAAE,cAmBlB,CAAA;AAiBD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsBnC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,iCAAiC,CAAC,KAAK,CACtC,CAAA;AAEtD,eAAO,MACa,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACnD,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC/B,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC9E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,2BAA2B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAChE,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACtF,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC3F,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAChG,MAAM,MAAM,yDAAyD,GACnE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,8DAA8D,GACxE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}