transloadit 4.14.0 → 5.0.1

package/src/alphalib/types/robots/text-translate.ts

@@ -1,29 +1,27 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  autoProviderDescription,
   awsGcpAiProviderSchema,
-  interpolateRobot,
+  createProcessingExample,
+  defineRobot,
+  robotArtificialIntelligenceMeta,
   robotBase,
+  robotParameterDocs,
   robotUse,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      translated: {
-        robot: '/text/translate',
-        use: ':original',
-        target_language: 'de',
-        provider: 'aws',
-      },
-    },
-  },
+  ...robotArtificialIntelligenceMeta,
+  example_code: createProcessingExample('translated', '/text/translate', {
+    target_language: 'de',
+    provider: 'aws',
+  }),
   example_code_description: 'Translate uploaded text file contents to German:',
   extended_description: `
 > [!Warning]
@@ -42,26 +40,16 @@ export const meta: RobotMetaInput = {
 
 {%- endfor %}
 `,
-  minimum_charge: 1048576,
-  output_factor: 1,
   override_lvl1: 'Artificial Intelligence',
   purpose_sentence: 'translates text in documents',
   purpose_verb: 'translate',
   purpose_word: 'text',
   purpose_words: 'Translate text in documents',
-  service_slug: 'artificial-intelligence',
-  slot_count: 10,
   title: 'Translate text',
   typical_file_size_mb: 1,
   typical_file_type: 'document',
   name: 'TextTranslateRobot',
   priceFactor: 0.00008,
-  queueSlotCount: 10,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 const translatableLanguages = z
@@ -193,11 +181,7 @@ You can use the text that we return in your application, or you can pass the tex
 > [!Note]
 > **This <dfn>Robot</dfn> accepts only files with a \`text/*\` MIME-type,** including plain text and Markdown. For documents in other formats, use [🤖/document/convert](/docs/robots/document-convert/) to first convert them into a compatible text format before proceeding.
 `),
-    provider: awsGcpAiProviderSchema.describe(`
-${autoProviderDescription}
-
-Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
-`),
+    provider: awsGcpAiProviderSchema.describe(robotParameterDocs.ai_provider.description),
     target_language: translatableLanguages.describe(`
 The desired language to translate to.
 
@@ -213,34 +197,23 @@ If the exact language can't be found, a generic variant can be fallen back to. F
   })
   .strict()
 
-export const robotTextTranslateInstructionsWithHiddenFieldsSchema =
-  robotTextTranslateInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotTextTranslateInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotTextTranslateInstructions = z.infer<typeof robotTextTranslateInstructionsSchema>
-export type RobotTextTranslateInstructionsWithHiddenFields = z.infer<
-  typeof robotTextTranslateInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotTextTranslateInstructionsSchema = interpolateRobot(
-  robotTextTranslateInstructionsSchema,
-)
-export type InterpolatableRobotTextTranslateInstructions =
-  InterpolatableRobotTextTranslateInstructionsInput
-
-export type InterpolatableRobotTextTranslateInstructionsInput = z.input<
-  typeof interpolatableRobotTextTranslateInstructionsSchema
->
-
-export const interpolatableRobotTextTranslateInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotTextTranslateInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotTextTranslateInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotTextTranslateInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotTextTranslateInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotTextTranslateInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotTextTranslateInstructionsSchema.shape> =
+  defineRobot(meta, robotTextTranslateInstructionsSchema)
+
+export const {
+  withHiddenFields: robotTextTranslateInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotTextTranslateInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotTextTranslateInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
+
+export type RobotTextTranslateInstructions = Instructions['output']
+export type RobotTextTranslateInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotTextTranslateInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotTextTranslateInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotTextTranslateInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotTextTranslateInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/tigris-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,
-  recursive,
+  bucketImportPath,
+  createStorageImportExample,
+  defineRobot,
+  recursiveImport,
+  recursiveImportPageNumber,
+  recursiveImportPageSize,
   return_file_stubs,
   robotBase,
   robotImport,
+  robotImportMeta,
   tigrisBase,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
-  example_code: {
-    steps: {
-      imported: {
-        robot: '/tigris/import',
-        credentials: 'YOUR_TIGRIS_CREDENTIALS',
-        path: 'path/to/files/',
-        recursive: true,
-      },
-    },
-  },
+  ...robotImportMeta,
+  example_code: createStorageImportExample('/tigris/import', 'YOUR_TIGRIS_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 Tigris bucket',
-  purpose_verb: 'import',
   purpose_word: 'Tigris',
   purpose_words: 'Import files from Tigris',
   requires_credentials: true,
-  service_slug: 'file-importing',
-  slot_count: 20,
   title: 'Import files from Tigris',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'TigrisImportRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 20,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-  stage: 'ga',
 }
 
 export const robotTigrisImportInstructionsSchema = robotBase
@@ -59,30 +39,10 @@ export const robotTigrisImportInstructionsSchema = robotBase
   .merge(tigrisBase)
   .extend({
     robot: z.literal('/tigris/import'),
-    path: path.describe(`
-The path in your bucket to the specific file or directory. If the path points to a file, only this file will be imported. For example: \`images/avatar.jpg\`.
-
-If it points to a directory, indicated by a trailing slash (\`/\`), then all files that are direct descendants of this directory will be imported. For example: \`images/\`.
-
-Directories are **not** imported recursively. If you want to import files from subdirectories and sub-subdirectories, enable the \`recursive\` parameter.
-
-If you want to import all files from the root directory, please use \`/\` as the value here. In this case, make sure all your objects belong to a path. If you have objects in the root of your bucket that aren't prefixed with \`/\`, you'll receive an error: \`A client error (NoSuchKey) occurred when calling the GetObject operation: The specified key does not exist.\`
-
-You can also use an array of path strings here to import multiple paths in the same <dfn>Robot</dfn>'s <dfn>Step</dfn>.
-`),
-    recursive: recursive.describe(`
-Setting this to \`true\` will enable importing files from subdirectories and sub-subdirectories (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.
-`),
+    path: bucketImportPath,
+    recursive: recursiveImport,
+    page_number: recursiveImportPageNumber,
+    files_per_page: recursiveImportPageSize,
     return_file_stubs,
     bucket_region: z
       .string()
@@ -91,34 +51,22 @@ The pagination page size. This only works when recursive is \`true\` for now, in
   })
   .strict()
 
-export const robotTigrisImportInstructionsWithHiddenFieldsSchema =
-  robotTigrisImportInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotTigrisImportInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotTigrisImportInstructions = z.infer<typeof robotTigrisImportInstructionsSchema>
-export type RobotTigrisImportInstructionsWithHiddenFields = z.infer<
-  typeof robotTigrisImportInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotTigrisImportInstructionsSchema.shape> =
+  defineRobot(meta, robotTigrisImportInstructionsSchema)
 
-export const interpolatableRobotTigrisImportInstructionsSchema = interpolateRobot(
-  robotTigrisImportInstructionsSchema,
-)
-export type InterpolatableRobotTigrisImportInstructions =
-  InterpolatableRobotTigrisImportInstructionsInput
+export const {
+  withHiddenFields: robotTigrisImportInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotTigrisImportInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotTigrisImportInstructionsInput = z.input<
-  typeof interpolatableRobotTigrisImportInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotTigrisImportInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotTigrisImportInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotTigrisImportInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema
->
+export type RobotTigrisImportInstructions = Instructions['output']
+export type RobotTigrisImportInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotTigrisImportInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotTigrisImportInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotTigrisImportInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotTigrisImportInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,45 +1,32 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse, tigrisBase } from './_instructions-primitives.ts'
+import {
+  createStorageStoreExample,
+  defineRobot,
+  robotBase,
+  robotStoreMeta,
+  robotUse,
+  storageAcl,
+  storeFilePath,
+  tigrisBase,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 6,
-  discount_factor: 0.15000150001500018,
-  discount_pct: 84.99984999849998,
-  example_code: {
-    steps: {
-      exported: {
-        robot: '/tigris/store',
-        use: ':original',
-        credentials: 'YOUR_TIGRIS_CREDENTIALS',
-        path: 'my_target_folder/${unique_prefix}/${file.url_name}',
-      },
-    },
-  },
+  ...robotStoreMeta,
+  example_code: createStorageStoreExample('/tigris/store', 'YOUR_TIGRIS_CREDENTIALS'),
   example_code_description: 'Export uploaded files to `my_target_folder` on Tigris:',
   has_small_icon: true,
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'File Exporting',
   purpose_sentence: 'exports encoding results to Tigris buckets',
-  purpose_verb: 'export',
   purpose_word: 'Tigris',
   purpose_words: 'Export files to Tigris',
-  service_slug: 'file-exporting',
-  slot_count: 10,
   title: 'Export files to Tigris',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'TigrisStoreRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 10,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotTigrisStoreInstructionsSchema = robotBase
@@ -49,18 +36,8 @@ export const robotTigrisStoreInstructionsSchema = robotBase
     robot: z.literal('/tigris/store').describe(`
 The URL to the result file will be returned in the <dfn>Assembly Status JSON</dfn>.
 `),
-    path: z
-      .string()
-      .default('${unique_prefix}/${file.url_name}')
-      .describe(`
-The path at which the file is to be stored. This may include any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables). The path must not be a directory.
-`),
-    acl: z
-      .enum(['private', 'public-read'])
-      .default('public-read')
-      .describe(`
-The permissions used for this file.
-`),
+    path: storeFilePath,
+    acl: storageAcl,
     headers: z
       .record(z.string())
       .default({ 'Content-Type': '${file.mime}' })
@@ -86,34 +63,22 @@ If this parameter is not used, no URL signing is done.
   })
   .strict()
 
-export const robotTigrisStoreInstructionsWithHiddenFieldsSchema =
-  robotTigrisStoreInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotTigrisStoreInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotTigrisStoreInstructions = z.infer<typeof robotTigrisStoreInstructionsSchema>
-export type RobotTigrisStoreInstructionsWithHiddenFields = z.infer<
-  typeof robotTigrisStoreInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotTigrisStoreInstructionsSchema.shape> =
+  defineRobot(meta, robotTigrisStoreInstructionsSchema)
 
-export const interpolatableRobotTigrisStoreInstructionsSchema = interpolateRobot(
-  robotTigrisStoreInstructionsSchema,
-)
-export type InterpolatableRobotTigrisStoreInstructions =
-  InterpolatableRobotTigrisStoreInstructionsInput
+export const {
+  withHiddenFields: robotTigrisStoreInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotTigrisStoreInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotTigrisStoreInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotTigrisStoreInstructionsInput = z.input<
-  typeof interpolatableRobotTigrisStoreInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotTigrisStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotTigrisStoreInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotTigrisStoreInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotTigrisStoreInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotTigrisStoreInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotTigrisStoreInstructionsWithHiddenFieldsSchema
->
+export type RobotTigrisStoreInstructions = Instructions['output']
+export type RobotTigrisStoreInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotTigrisStoreInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotTigrisStoreInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotTigrisStoreInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotTigrisStoreInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/tlcdn-deliver.ts

@@ -1,13 +1,15 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase } from './_instructions-primitives.ts'
+import { defineRobot, robotBase, robotContentDeliveryMeta } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 25,
-  discount_factor: 0.04,
-  discount_pct: 96,
+  ...robotContentDeliveryMeta,
   example_code: {
     steps: {
       deliver: {
@@ -16,31 +18,17 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description: 'Cache and deliver files over Smart CDN using the tlcdn.com domain:',
-  minimum_charge: 102400,
-  output_factor: 1,
   override_lvl1: 'Content Delivery',
   purpose_sentence: 'caches and delivers files globally',
   purpose_verb: 'cache & deliver',
   purpose_word: 'Cache and deliver files',
   purpose_words: 'Cache and deliver files globally',
-  service_slug: 'content-delivery',
-  slot_count: 0,
   title: 'Cache and deliver files globally',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'TlcdnDeliverRobot',
   // Baseline factor for non-HIPAA delivery; HIPAA delivery uses a 20% lower factor.
   priceFactor: 25,
-  queueSlotCount: 0,
   minimumCharge: 102400,
   minimumChargeUsd: 0.0000152587890625,
-  downloadInputFiles: false,
-  preserveInputFileUrls: true,
-  isAllowedForUrlTransform: false,
-  trackOutputFileSize: false,
-  isInternal: true,
-  stage: 'ga',
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
 }
 
 export const robotTlcdnDeliverInstructionsSchema = robotBase
@@ -58,34 +46,22 @@ When you want Transloadit to transform files on the fly, this <dfn>Robot</dfn> c
   })
   .strict()
 
-export const robotTlcdnDeliverInstructionsWithHiddenFieldsSchema =
-  robotTlcdnDeliverInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotTlcdnDeliverInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotTlcdnDeliverInstructions = z.infer<typeof robotTlcdnDeliverInstructionsSchema>
-export type RobotTlcdnDeliverInstructionsWithHiddenFields = z.infer<
-  typeof robotTlcdnDeliverInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotTlcdnDeliverInstructionsSchema.shape> =
+  defineRobot(meta, robotTlcdnDeliverInstructionsSchema)
 
-export const interpolatableRobotTlcdnDeliverInstructionsSchema = interpolateRobot(
-  robotTlcdnDeliverInstructionsSchema,
-)
-export type InterpolatableRobotTlcdnDeliverInstructions =
-  InterpolatableRobotTlcdnDeliverInstructionsInput
+export const {
+  withHiddenFields: robotTlcdnDeliverInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotTlcdnDeliverInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotTlcdnDeliverInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotTlcdnDeliverInstructionsInput = z.input<
-  typeof interpolatableRobotTlcdnDeliverInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotTlcdnDeliverInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotTlcdnDeliverInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotTlcdnDeliverInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotTlcdnDeliverInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotTlcdnDeliverInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotTlcdnDeliverInstructionsWithHiddenFieldsSchema
->
+export type RobotTlcdnDeliverInstructions = Instructions['output']
+export type RobotTlcdnDeliverInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotTlcdnDeliverInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotTlcdnDeliverInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotTlcdnDeliverInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotTlcdnDeliverInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,16 +1,9 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import { damIdSchema } from '../storageAsset.ts'
-import {
-  booleanStringSchema,
-  interpolateRobot,
-  interpolationSchemaFull,
-  recursive,
-  robotBase,
-  robotImport,
-} from './_instructions-primitives.ts'
+import { interpolateRobot, recursive, robotBase, robotImport } from './_instructions-primitives.ts'
 
 /** Cross-field validation runs after interpolation-aware parsing at the Assembly Step boundary. */
 export function refineTransloaditImportSelector(
@@ -47,10 +40,15 @@ Whether to import files from subfolders and sub-subfolders when \`path\` is a fo
 only the folder's own files are imported.
 `
 
+/** Storage imports require proof of possession independently of Workspace signature settings. */
+export const transloaditImportAuthenticationGuidanceLines = [
+  'Assemblies that use `/transloadit/import`, directly or through a Template, require',
+  'either a bearer token or signed `params` with a future `params.auth.expires` timestamp.',
+  'This applies even when Workspace Signature Authentication is disabled. An Auth Key alone',
+  'is not sufficient; bearer-authenticated requests do not need a separate signature or expiry.',
+] as const
+
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
   example_code: {
     steps: {
       imported: {
@@ -63,9 +61,7 @@ export const meta: RobotMetaInput = {
   has_small_icon: true,
   isAllowedForUrlTransform: true,
   isInternal: false,
-  minimum_charge: 0,
   name: 'TransloaditImportRobot',
-  output_factor: 1,
   override_lvl1: 'File Importing',
   priceFactor: 10,
   purpose_sentence: 'imports files from Transloadit Storage',
@@ -75,7 +71,6 @@ export const meta: RobotMetaInput = {
   queueSlotCount: 10,
   removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
   service_slug: 'file-importing',
-  slot_count: 10,
   stage: 'beta',
   title: 'Import files from Transloadit Storage',
   typical_file_size_mb: 1.2,
@@ -89,6 +84,8 @@ export const robotTransloaditImportInstructionsSchema = robotBase
 Imports files from your Workspace's Transloadit Storage. Select a mutable location with
 \`path\`, or a logical asset with \`asset_id\`. Add \`version_id\` to pin the exact stored bytes.
 IDs remain subject to Workspace access and version retention.
+
+${transloaditImportAuthenticationGuidanceLines.join('\n')}
 `),
     path: z
       .string()
@@ -125,17 +122,7 @@ export type RobotTransloaditImportInstructionsWithHiddenFields = z.infer<
 
 export const interpolatableRobotTransloaditImportInstructionsSchema = interpolateRobot(
   robotTransloaditImportInstructionsSchema,
-).extend({
-  // The generic boolean interpolator changes literal false to true. Keep Storage's documented
-  // false default intact; unresolved variables are validated after uploader interpolation.
-  recursive: z
-    .union([
-      recursive,
-      booleanStringSchema.transform((value) => value === 'true'),
-      interpolationSchemaFull,
-    ])
-    .describe(recursiveDescription),
-})
+)
 export type InterpolatableRobotTransloaditImportInstructions =
   InterpolatableRobotTransloaditImportInstructionsInput
 
@@ -144,11 +131,19 @@ export type InterpolatableRobotTransloaditImportInstructionsInput = z.input<
 >
 
 export const interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema =
-  interpolateRobot(robotTransloaditImportInstructionsWithHiddenFieldsSchema).extend({
-    recursive: interpolatableRobotTransloaditImportInstructionsSchema.shape.recursive,
-  })
+  interpolateRobot(robotTransloaditImportInstructionsWithHiddenFieldsSchema)
 export type InterpolatableRobotTransloaditImportInstructionsWithHiddenFields =
   InterpolatableRobotTransloaditImportInstructionsWithHiddenFieldsInput
 export type InterpolatableRobotTransloaditImportInstructionsWithHiddenFieldsInput = z.input<
   typeof interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema
 >
+
+export const robotDefinition: RobotSchemaPair<
+  typeof interpolatableRobotTransloaditImportInstructionsSchema,
+  typeof interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema
+> = {
+  meta,
+  interpolatable: interpolatableRobotTransloaditImportInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema,
+}