@transloadit/zod 4.5.0 → 5.0.0

package/dist/v3/robots/sftp-store.js

@@ -1,52 +1,21 @@
 import { z } from 'zod/v3';
-import { interpolateRobot, robotBase, robotUse, sftpBase } from "./_instructions-primitives.js";
+import { createStorageStoreExample, defineRobotWithHiddenFields, robotBase, robotStoreMeta, robotUse, sftpBase, storePath, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 6,
-    discount_factor: 0.15000150001500018,
-    discount_pct: 84.99984999849998,
-    example_code: {
-        steps: {
-            exported: {
-                robot: '/sftp/store',
-                use: ':original',
-                credentials: 'YOUR_SFTP_CREDENTIALS',
-                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
-            },
-        },
-    },
+    ...robotStoreMeta,
+    example_code: createStorageStoreExample('/sftp/store', 'YOUR_SFTP_CREDENTIALS'),
     example_code_description: 'Export uploaded files to `my_target_folder` on an SFTP server:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Exporting',
     purpose_sentence: 'exports encoding results to your own SFTP server',
-    purpose_verb: 'export',
     purpose_word: 'SFTP servers',
     purpose_words: 'Export files to SFTP servers',
-    service_slug: 'file-exporting',
-    slot_count: 10,
     title: 'Export files to SFTP servers',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'SftpStoreRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotSftpStoreInstructionsSchema = robotBase
     .merge(robotUse)
     .merge(sftpBase)
     .extend({
     robot: z.literal('/sftp/store'),
-    path: z
-        .string()
-        .default('${unique_prefix}/${file.url_name}')
-        .describe(`
-The path at which the file is to be stored. This may include any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables).
-`),
+    path: storePath,
     url_template: z
         .string()
         .default('http://host/path')
@@ -61,21 +30,20 @@ The URL of the file in the result JSON. This may include any of the following su
 `),
     file_chmod: z
         .string()
-        .regex(/([0-7]{3}|auto)/)
+        .regex(/([0-7]{3}|auto)/u)
         .default('auto')
         .describe(`
 This optional parameter controls how an uploaded file's permission bits are set. You can use any string format that the \`chmod\` command would accept, such as \`"755"\`. If you don't specify this option, the file's permission bits aren't changed at all, meaning it's up to your server's configuration (e.g. umask).
       `),
 })
     .strict();
-export const robotSftpStoreInstructionsWithHiddenFieldsSchema = robotSftpStoreInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotSftpStoreInstructionsSchema.shape.result]).optional(),
+const hiddenFields = {
     allowNetwork: z
         .string()
         .optional()
         .describe(`
 Network access permission for the SFTP connection. This is used to control which networks the SFTP robot can access.
 `),
-});
-export const interpolatableRobotSftpStoreInstructionsSchema = interpolateRobot(robotSftpStoreInstructionsSchema);
-export const interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotSftpStoreInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotSftpStoreInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotSftpStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotSftpStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v3/robots/speech-transcribe.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotSpeechTranscribeInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -61,24 +62,23 @@ export declare const robotSpeechTranscribeInstructionsSchema: z.ZodObject<{
     robot: z.ZodLiteral<"/speech/transcribe">;
     provider: z.ZodDefault<z.ZodEnum<["auto", "aws", "gcp", "replicate"]>>;
     granularity: z.ZodDefault<z.ZodEnum<["full", "list"]>>;
-    format: z.ZodDefault<z.ZodEnum<["json", "meta", "srt", "meta", "text", "webvtt"]>>;
+    format: z.ZodDefault<z.ZodEnum<["json", "meta", "srt", "text", "webvtt"]>>;
     speaker_labels: z.ZodDefault<z.ZodBoolean>;
     max_speakers: z.ZodDefault<z.ZodNumber>;
     source_language: z.ZodDefault<z.ZodString>;
-    target_language: z.ZodDefault<z.ZodString>;
+    target_language: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/speech/transcribe";
     result: boolean;
+    robot: "/speech/transcribe";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    format: "meta" | "json" | "text" | "srt" | "webvtt";
-    provider: "auto" | "aws" | "gcp" | "replicate";
+    format: "json" | "text" | "meta" | "srt" | "webvtt";
+    provider: "aws" | "gcp" | "replicate" | "auto";
     granularity: "full" | "list";
     speaker_labels: boolean;
     max_speakers: number;
     source_language: string;
-    target_language: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -93,11 +93,13 @@ export declare const robotSpeechTranscribeInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
+    target_language?: string | undefined;
 }, {
     robot: "/speech/transcribe";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -112,22 +114,29 @@ export declare const robotSpeechTranscribeInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
-    format?: "meta" | "json" | "text" | "srt" | "webvtt" | undefined;
-    provider?: "auto" | "aws" | "gcp" | "replicate" | undefined;
+    format?: "json" | "text" | "meta" | "srt" | "webvtt" | undefined;
+    provider?: "aws" | "gcp" | "replicate" | "auto" | undefined;
     granularity?: "full" | "list" | undefined;
+    target_language?: string | undefined;
     speaker_labels?: boolean | undefined;
     max_speakers?: number | undefined;
     source_language?: string | undefined;
-    target_language?: string | undefined;
 }>;
+declare const hiddenFields: {
+    model: z.ZodOptional<z.ZodEnum<["whisper-large-v3"]>>;
+    provider: z.ZodDefault<z.ZodEnum<["auto", "aws", "gcp", "replicate", "transloadit"]>>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotSpeechTranscribeInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotSpeechTranscribeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
@@ -181,27 +190,27 @@ export declare const robotSpeechTranscribeInstructionsWithHiddenFieldsSchema: z.
     }>]>>;
     robot: z.ZodLiteral<"/speech/transcribe">;
     granularity: z.ZodDefault<z.ZodEnum<["full", "list"]>>;
-    format: z.ZodDefault<z.ZodEnum<["json", "meta", "srt", "meta", "text", "webvtt"]>>;
+    format: z.ZodDefault<z.ZodEnum<["json", "meta", "srt", "text", "webvtt"]>>;
     speaker_labels: z.ZodDefault<z.ZodBoolean>;
     max_speakers: z.ZodDefault<z.ZodNumber>;
     source_language: z.ZodDefault<z.ZodString>;
-    target_language: z.ZodDefault<z.ZodString>;
+    target_language: z.ZodOptional<z.ZodString>;
 } & {
+    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
     model: z.ZodOptional<z.ZodEnum<["whisper-large-v3"]>>;
     provider: z.ZodDefault<z.ZodEnum<["auto", "aws", "gcp", "replicate", "transloadit"]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/speech/transcribe";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    format: "meta" | "json" | "text" | "srt" | "webvtt";
-    provider: "auto" | "aws" | "gcp" | "replicate" | "transloadit";
+    format: "json" | "text" | "meta" | "srt" | "webvtt";
+    provider: "aws" | "gcp" | "replicate" | "auto" | "transloadit";
     granularity: "full" | "list";
     speaker_labels: boolean;
     max_speakers: number;
     source_language: string;
-    target_language: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -216,13 +225,14 @@ export declare const robotSpeechTranscribeInstructionsWithHiddenFieldsSchema: z.
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     model?: "whisper-large-v3" | undefined;
+    target_language?: string | undefined;
 }, {
     robot: "/speech/transcribe";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -237,25 +247,24 @@ export declare const robotSpeechTranscribeInstructionsWithHiddenFieldsSchema: z.
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     model?: "whisper-large-v3" | undefined;
-    format?: "meta" | "json" | "text" | "srt" | "webvtt" | undefined;
-    provider?: "auto" | "aws" | "gcp" | "replicate" | "transloadit" | undefined;
+    format?: "json" | "text" | "meta" | "srt" | "webvtt" | undefined;
+    provider?: "aws" | "gcp" | "replicate" | "auto" | "transloadit" | undefined;
     granularity?: "full" | "list" | undefined;
+    target_language?: string | undefined;
     speaker_labels?: boolean | undefined;
     max_speakers?: number | undefined;
     source_language?: string | undefined;
-    target_language?: string | undefined;
-}>;
-export type RobotSpeechTranscribeInstructions = z.infer<typeof robotSpeechTranscribeInstructionsSchema>;
-export type RobotSpeechTranscribeInstructionsWithHiddenFields = z.infer<typeof robotSpeechTranscribeInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotSpeechTranscribeInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotSpeechTranscribeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -311,14 +320,15 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsSchema: z.Zo
     robot: z.ZodLiteral<"/speech/transcribe">;
     provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["auto", "aws", "gcp", "replicate"]>]>>;
     granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["full", "list"]>]>>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["json", "meta", "srt", "meta", "text", "webvtt"]>]>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["json", "meta", "srt", "text", "webvtt"]>]>>;
     speaker_labels: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     max_speakers: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     source_language: z.ZodDefault<z.ZodString>;
-    target_language: z.ZodDefault<z.ZodString>;
+    target_language: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/speech/transcribe";
     result: string | boolean;
+    robot: "/speech/transcribe";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     format: string;
@@ -327,8 +337,6 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsSchema: z.Zo
     speaker_labels: string | boolean;
     max_speakers: string | number;
     source_language: string;
-    target_language: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -343,11 +351,13 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsSchema: z.Zo
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
+    target_language?: string | undefined;
 }, {
     robot: "/speech/transcribe";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -362,24 +372,23 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsSchema: z.Zo
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     format?: string | undefined;
     provider?: string | undefined;
     granularity?: string | undefined;
+    target_language?: string | undefined;
     speaker_labels?: string | boolean | undefined;
     max_speakers?: string | number | undefined;
     source_language?: string | undefined;
-    target_language?: string | undefined;
-}>;
-export type InterpolatableRobotSpeechTranscribeInstructions = InterpolatableRobotSpeechTranscribeInstructionsInput;
-export type InterpolatableRobotSpeechTranscribeInstructionsInput = z.input<typeof interpolatableRobotSpeechTranscribeInstructionsSchema>;
-export declare const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
@@ -433,16 +442,17 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFi
     }>]>>;
     robot: z.ZodLiteral<"/speech/transcribe">;
     granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["full", "list"]>]>>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["json", "meta", "srt", "meta", "text", "webvtt"]>]>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["json", "meta", "srt", "text", "webvtt"]>]>>;
     speaker_labels: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     max_speakers: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     source_language: z.ZodDefault<z.ZodString>;
-    target_language: z.ZodDefault<z.ZodString>;
+    target_language: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
     model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["whisper-large-v3"]>]>>;
     provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["auto", "aws", "gcp", "replicate", "transloadit"]>]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/speech/transcribe";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     format: string;
@@ -451,8 +461,7 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFi
     speaker_labels: string | boolean;
     max_speakers: string | number;
     source_language: string;
-    target_language: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -467,13 +476,14 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFi
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     model?: string | undefined;
+    target_language?: string | undefined;
 }, {
     robot: "/speech/transcribe";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -488,8 +498,9 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFi
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
@@ -497,11 +508,17 @@ export declare const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFi
     format?: string | undefined;
     provider?: string | undefined;
     granularity?: string | undefined;
+    target_language?: string | undefined;
     speaker_labels?: string | boolean | undefined;
     max_speakers?: string | number | undefined;
     source_language?: string | undefined;
-    target_language?: string | undefined;
 }>;
-export type InterpolatableRobotSpeechTranscribeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotSpeechTranscribeInstructions = Instructions['output'];
+export type RobotSpeechTranscribeInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotSpeechTranscribeInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotSpeechTranscribeInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotSpeechTranscribeInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=speech-transcribe.d.ts.map

package/dist/v3/robots/speech-transcribe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"speech-transcribe.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/speech-transcribe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAe1B,eAAO,MAAM,IAAI,EAAE,cA6ClB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,qEAAqE,CAC7E,CAAA;AACD,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA"}
+{"version":3,"file":"speech-transcribe.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/speech-transcribe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAiB1B,eAAO,MAAM,IAAI,EAAE,cA2BlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGzC,CAAA;AAEX,QAAA,MAAM,YAAY;;;CAGjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,uCAAuC,CAAC,KAAK,EACpD,OAAO,YAAY,CACuE,CAAA;AAE5F,eAAO,MACa,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACzD,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEnE,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACtD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,iCAAiC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACtE,MAAM,MAAM,iDAAiD,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAC5F,MAAM,MAAM,+CAA+C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACjG,MAAM,MAAM,oDAAoD,GAC9D,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,+DAA+D,GACzE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,oEAAoE,GAC9E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v3/robots/speech-transcribe.js

@@ -1,53 +1,35 @@
 import { z } from 'zod/v3';
-import { autoProviderDescription, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, createProcessingExample, defineRobotWithHiddenFields, granularitySchema, robotArtificialIntelligenceMeta, robotBase, robotUse, } from "./_instructions-primitives.js";
 const speechTranscribeProviderSchema = z.enum(['auto', 'aws', 'gcp', 'replicate']).default('auto');
 const speechTranscribeProviderWithHiddenFieldsSchema = z
     .enum(['auto', 'aws', 'gcp', 'replicate', 'transloadit'])
     .default('auto');
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            transcribed: {
-                robot: '/speech/transcribe',
-                use: ':original',
-                provider: 'replicate',
-                source_language: 'fr-FR',
-                format: 'text',
-            },
-        },
-    },
-    example_code_description: 'Transcribe speech in French from uploaded audio or video, and save it to a text file:',
+    ...robotArtificialIntelligenceMeta,
+    example_code: createProcessingExample('transcribed', '/speech/transcribe', {
+        provider: 'replicate',
+        target_language: 'french',
+        format: 'text',
+    }),
+    example_code_description: 'Transcribe French speech from uploaded audio or video, and save it to a text file:',
     extended_description: `
 > [!Warning]
 > Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses AI services. The providers will evolve their models over time, giving different responses for the same input media. Avoid relying on exact responses in your tests and application.
 `,
-    minimum_charge: 1048576,
-    output_factor: 0.05,
     override_lvl1: 'Artificial Intelligence',
     purpose_sentence: 'transcribes speech in audio or video files',
     purpose_verb: 'transcribe',
     purpose_word: 'transcribe speech',
     purpose_words: 'Transcribe speech in audio or video files',
-    service_slug: 'artificial-intelligence',
-    slot_count: 10,
     title: 'Transcribe speech in audio or video files',
     typical_file_size_mb: 2.4,
     typical_file_type: 'audio or video file',
     name: 'SpeechTranscribeRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsdPerSpeechTranscribeMinute: {
         aws: 0.024,
         gcp: 0.024,
+        replicate: 'variable',
     },
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotSpeechTranscribeInstructionsSchema = robotBase
     .merge(robotUse)
@@ -98,14 +80,14 @@ are normalized as \`speaker_1\`, \`speaker_2\`, and so on:
 ${autoProviderDescription}
 
 Set this to \`"aws"\`, \`"gcp"\`, or \`"replicate"\` to force a specific provider.
-When set to \`"auto"\`, Transloadit keeps the existing transcription default and uses \`"aws"\` only
-when \`speaker_labels\` is enabled.
+When set to \`"auto"\`, Transloadit uses \`"replicate"\` by default and uses \`"aws"\` when
+\`speaker_labels\` is enabled.
 `),
     granularity: granularitySchema.describe(`
-Whether to return a full response (\`"full"\`), or a flat list of descriptions (\`"list"\`).
+Both \`"full"\` and \`"list"\` currently return the same complete transcription response. \`"list"\` remains accepted for backward compatibility.
 `),
     format: z
-        .enum(['json', 'meta', 'srt', 'meta', 'text', 'webvtt'])
+        .enum(['json', 'meta', 'srt', 'text', 'webvtt'])
         .default('json')
         .describe(`
 Output format for the transcription.
@@ -137,27 +119,24 @@ The maximum number of speakers to detect when \`speaker_labels\` is enabled.
         .string()
         .default('en-US')
         .describe(`
-The spoken language of the audio or video. This will also be the language of the transcribed text.
+Sets the spoken language for the \`"aws"\` and \`"gcp"\` providers. The transcription stays in the spoken language; this parameter does not translate speech.
 
-The language should be specified in the [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) format, such as \`"en-GB"\`, \`"de-DE"\` or \`"fr-FR"\`. Please also consult the list of supported languages for [the \`gcp\` provider](https://cloud.google.com/speech-to-text/docs/languages) and the [the \`aws\` provider](https://docs.aws.amazon.com/transcribe/latest/dg/what-is-transcribe.html).
+The language should be specified in the [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) format, such as \`"en-GB"\`, \`"de-DE"\` or \`"fr-FR"\`. Please also consult the list of supported languages for [the \`gcp\` provider](https://cloud.google.com/speech-to-text/docs/languages) and [the \`aws\` provider](https://docs.aws.amazon.com/transcribe/latest/dg/what-is-transcribe.html).
 `),
     // TODO determine the list of languages
     target_language: z
         .string()
-        .default('en-US')
+        .optional()
         .describe(`
-      This will also be the language of the written text.
+Sets the spoken language hint for the \`"replicate"\` provider. Omit this parameter to detect the spoken language automatically. Set it to the full lowercase English language name, such as \`"french"\`, when the spoken language is known. Despite its name, this parameter does not translate speech.
 
-      The language should be specified in the [BCP-47](https://www.rfc-editor.org/rfc/bcp/bcp47.txt) format, such as \`"en-GB"\`, \`"de-DE"\` or \`"fr-FR"\`. Please consult the list of supported languages and voices.
-    `),
+For the \`"aws"\` and \`"gcp"\` providers, use \`source_language\` instead.
+`),
 })
     .strict();
-export const robotSpeechTranscribeInstructionsWithHiddenFieldsSchema = robotSpeechTranscribeInstructionsSchema.extend({
+const hiddenFields = {
     model: z.enum(['whisper-large-v3']).optional(),
     provider: speechTranscribeProviderWithHiddenFieldsSchema,
-    result: z
-        .union([z.literal('debug'), robotSpeechTranscribeInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotSpeechTranscribeInstructionsSchema = interpolateRobot(robotSpeechTranscribeInstructionsSchema);
-export const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotSpeechTranscribeInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotSpeechTranscribeInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotSpeechTranscribeInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotSpeechTranscribeInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema, } = robotDefinition;