transloadit 4.14.0 → 5.0.0

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

@@ -1,52 +1,32 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  interpolateRobot,
+  createStorageImportExample,
+  defineRobotWithHiddenFields,
   recursive,
   robotBase,
   robotImport,
+  robotImportMeta,
   sftpBase,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
-  example_code: {
-    steps: {
-      imported: {
-        robot: '/sftp/import',
-        credentials: 'YOUR_SFTP_CREDENTIALS',
-        path: 'path/to/files/',
-        recursive: true,
-      },
-    },
-  },
+  ...robotImportMeta,
+  example_code: createStorageImportExample('/sftp/import', 'YOUR_SFTP_CREDENTIALS'),
   example_code_description:
     'Import files from the `path/to/files` directory and its subdirectories:',
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'File Importing',
   purpose_sentence:
     'imports whole libraries of files from your SFTP servers into Transloadit. This Robot relies on public key authentication',
-  purpose_verb: 'import',
   purpose_word: 'SFTP servers',
   purpose_words: 'Import files from SFTP servers',
-  service_slug: 'file-importing',
-  slot_count: 20,
   title: 'Import files from SFTP servers',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'SftpImportRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 20,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-  stage: 'ga',
 }
 
 export const robotSftpImportInstructionsSchema = robotBase
@@ -63,40 +43,33 @@ Setting this to \`true\` will enable importing files from subdirectories and sub
   })
   .strict()
 
-export const robotSftpImportInstructionsWithHiddenFieldsSchema =
-  robotSftpImportInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotSftpImportInstructionsSchema.shape.result])
-      .optional(),
-    allowNetwork: z
-      .string()
-      .optional()
-      .describe(`
+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 type RobotSftpImportInstructions = z.infer<typeof robotSftpImportInstructionsSchema>
-export type RobotSftpImportInstructionsWithHiddenFields = z.infer<
-  typeof robotSftpImportInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotSftpImportInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotSftpImportInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotSftpImportInstructionsSchema = interpolateRobot(
-  robotSftpImportInstructionsSchema,
-)
-export type InterpolatableRobotSftpImportInstructions =
-  InterpolatableRobotSftpImportInstructionsInput
+export const {
+  withHiddenFields: robotSftpImportInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotSftpImportInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotSftpImportInstructionsInput = z.input<
-  typeof interpolatableRobotSftpImportInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotSftpImportInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotSftpImportInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotSftpImportInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema
->
+export type RobotSftpImportInstructions = Instructions['output']
+export type RobotSftpImportInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotSftpImportInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotSftpImportInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotSftpImportInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotSftpImportInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,44 +1,30 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse, sftpBase } from './_instructions-primitives.ts'
+import {
+  createStorageStoreExample,
+  defineRobotWithHiddenFields,
+  robotBase,
+  robotStoreMeta,
+  robotUse,
+  sftpBase,
+  storePath,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  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
@@ -46,12 +32,7 @@ export const robotSftpStoreInstructionsSchema = robotBase
   .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')
@@ -66,7 +47,7 @@ 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).
@@ -74,37 +55,33 @@ This optional parameter controls how an uploaded file's permission bits are set.
   })
   .strict()
 
-export const robotSftpStoreInstructionsWithHiddenFieldsSchema =
-  robotSftpStoreInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotSftpStoreInstructionsSchema.shape.result]).optional(),
-    allowNetwork: z
-      .string()
-      .optional()
-      .describe(`
+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 type RobotSftpStoreInstructions = z.infer<typeof robotSftpStoreInstructionsSchema>
-export type RobotSftpStoreInstructionsWithHiddenFields = z.infer<
-  typeof robotSftpStoreInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotSftpStoreInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotSftpStoreInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotSftpStoreInstructionsSchema = interpolateRobot(
-  robotSftpStoreInstructionsSchema,
-)
-export type InterpolatableRobotSftpStoreInstructions = InterpolatableRobotSftpStoreInstructionsInput
+export const {
+  withHiddenFields: robotSftpStoreInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotSftpStoreInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotSftpStoreInstructionsInput = z.input<
-  typeof interpolatableRobotSftpStoreInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotSftpStoreInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotSftpStoreInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotSftpStoreInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema
->
+export type RobotSftpStoreInstructions = Instructions['output']
+export type RobotSftpStoreInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotSftpStoreInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotSftpStoreInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotSftpStoreInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotSftpStoreInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/speech-transcribe.ts

@@ -1,11 +1,17 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
   autoProviderDescription,
+  createProcessingExample,
+  defineRobotWithHiddenFields,
   granularitySchema,
-  interpolateRobot,
+  robotArtificialIntelligenceMeta,
   robotBase,
   robotUse,
 } from './_instructions-primitives.ts'
@@ -16,50 +22,32 @@ const speechTranscribeProviderWithHiddenFieldsSchema = z
   .default('auto')
 
 export const meta: RobotMetaInput = {
-  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',
-      },
-    },
-  },
+  ...robotArtificialIntelligenceMeta,
+  example_code: createProcessingExample('transcribed', '/speech/transcribe', {
+    provider: 'replicate',
+    target_language: 'french',
+    format: 'text',
+  }),
   example_code_description:
-    'Transcribe speech in French from uploaded audio or video, and save it to a text file:',
+    '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
@@ -111,14 +99,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.
@@ -150,53 +138,47 @@ 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({
-    model: z.enum(['whisper-large-v3']).optional(),
-    provider: speechTranscribeProviderWithHiddenFieldsSchema,
-    result: z
-      .union([z.literal('debug'), robotSpeechTranscribeInstructionsSchema.shape.result])
-      .optional(),
-  })
+const hiddenFields = {
+  model: z.enum(['whisper-large-v3']).optional(),
+  provider: speechTranscribeProviderWithHiddenFieldsSchema,
+}
 
-export type RobotSpeechTranscribeInstructions = z.infer<
-  typeof robotSpeechTranscribeInstructionsSchema
->
-export type RobotSpeechTranscribeInstructionsWithHiddenFields = z.infer<
-  typeof robotSpeechTranscribeInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotSpeechTranscribeInstructionsSchema = interpolateRobot(
-  robotSpeechTranscribeInstructionsSchema,
-)
-export type InterpolatableRobotSpeechTranscribeInstructions =
-  InterpolatableRobotSpeechTranscribeInstructionsInput
-
-export type InterpolatableRobotSpeechTranscribeInstructionsInput = z.input<
-  typeof interpolatableRobotSpeechTranscribeInstructionsSchema
->
-
-export const interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema =
-  interpolateRobot(robotSpeechTranscribeInstructionsWithHiddenFieldsSchema)
-export type InterpolatableRobotSpeechTranscribeInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotSpeechTranscribeInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotSpeechTranscribeInstructionsSchema, hiddenFields)
+
+export const {
+  withHiddenFields: robotSpeechTranscribeInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotSpeechTranscribeInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotSpeechTranscribeInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+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']

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

@@ -1,57 +1,37 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  files_per_page,
-  interpolateRobot,
-  page_number,
-  path,
+  bucketImportPath,
+  createStorageImportExample,
+  defineRobot,
   recursive,
+  recursiveImportPageNumber,
+  recursiveImportPageSize,
   return_file_stubs,
   robotBase,
   robotImport,
+  robotImportMeta,
   supabaseBase,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
-  example_code: {
-    steps: {
-      imported: {
-        robot: '/supabase/import',
-        credentials: 'YOUR_SUPABASE_CREDENTIALS',
-        path: 'path/to/files/',
-        recursive: true,
-      },
-    },
-  },
+  ...robotImportMeta,
+  example_code: createStorageImportExample('/supabase/import', 'YOUR_SUPABASE_CREDENTIALS'),
   example_code_description:
     'Import files from the `path/to/files` directory and its subdirectories:',
   has_small_icon: true,
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'File Importing',
-  purpose_sentence: 'imports whole directories of files from your Supabase bucket',
-  purpose_verb: 'import',
-  purpose_word: 'Supabase',
-  purpose_words: 'Import files from Supabase',
+  purpose_sentence: 'imports whole directories of files from your Supabase Storage bucket',
+  purpose_word: 'Supabase Storage',
+  purpose_words: 'Import files from Supabase Storage',
   requires_credentials: true,
-  service_slug: 'file-importing',
-  slot_count: 20,
-  title: 'Import files from Supabase',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
+  title: 'Import files from Supabase Storage',
   name: 'SupabaseImportRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 20,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-  stage: 'ga',
 }
 
 export const robotSupabaseImportInstructionsSchema = robotBase
@@ -61,62 +41,35 @@ export const robotSupabaseImportInstructionsSchema = robotBase
     robot: z.literal('/supabase/import').describe(`
 The URL to the result file will be returned in the <dfn>Assembly Status JSON</dfn>.
 `),
-    path: path.describe(`
-The path in your bucket to the specific file or directory. If the path points to a file, only this file will be imported. For example: \`images/avatar.jpg\`.
-
-If it points to a directory, indicated by a trailing slash (\`/\`), then all files that are direct descendants of this directory will be imported. For example: \`images/\`.
-
-Directories are **not** imported recursively. If you want to import files from subdirectories and sub-subdirectories, enable the \`recursive\` parameter.
-
-If you want to import all files from the root directory, please use \`/\` as the value here. In this case, make sure all your objects belong to a path. If you have objects in the root of your bucket that aren't prefixed with \`/\`, you'll receive an error: \`A client error (NoSuchKey) occurred when calling the GetObject operation: The specified key does not exist.\`
-
-You can also use an array of path strings here to import multiple paths in the same <dfn>Robot</dfn>'s <dfn>Step</dfn>.
-`),
+    path: bucketImportPath,
     recursive: recursive.describe(`
 Setting this to \`true\` will enable importing files from subfolders and sub-subfolders, etc. of the given path.
 
 Please use the pagination parameters \`page_number\` and \`files_per_page\` wisely here.
 `),
-    page_number: page_number.describe(`
-The pagination page number. For now, in order to not break backwards compatibility in non-recursive imports, this only works when recursive is set to \`true\`.
-
-When doing big imports, make sure no files are added or removed from other scripts within your path, otherwise you might get weird results with the pagination.
-`),
-    files_per_page: files_per_page.describe(`
-The pagination page size. This only works when recursive is \`true\` for now, in order to not break backwards compatibility in non-recursive imports.
-`),
+    page_number: recursiveImportPageNumber,
+    files_per_page: recursiveImportPageSize,
     return_file_stubs,
   })
   .strict()
 
-export const robotSupabaseImportInstructionsWithHiddenFieldsSchema =
-  robotSupabaseImportInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotSupabaseImportInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotSupabaseImportInstructions = z.infer<typeof robotSupabaseImportInstructionsSchema>
-export type RobotSupabaseImportInstructionsWithHiddenFields = z.infer<
-  typeof robotSupabaseImportInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotSupabaseImportInstructionsSchema.shape> =
+  defineRobot(meta, robotSupabaseImportInstructionsSchema)
 
-export const interpolatableRobotSupabaseImportInstructionsSchema = interpolateRobot(
-  robotSupabaseImportInstructionsSchema,
-)
-export type InterpolatableRobotSupabaseImportInstructions =
-  InterpolatableRobotSupabaseImportInstructionsInput
+export const {
+  withHiddenFields: robotSupabaseImportInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotSupabaseImportInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotSupabaseImportInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotSupabaseImportInstructionsInput = z.input<
-  typeof interpolatableRobotSupabaseImportInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotSupabaseImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotSupabaseImportInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotSupabaseImportInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotSupabaseImportInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotSupabaseImportInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotSupabaseImportInstructionsWithHiddenFieldsSchema
->
+export type RobotSupabaseImportInstructions = Instructions['output']
+export type RobotSupabaseImportInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotSupabaseImportInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotSupabaseImportInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotSupabaseImportInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotSupabaseImportInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']