transloadit 4.14.0 → 5.0.0

package/src/alphalib/types/robots/file-verify.ts

@@ -1,47 +1,37 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+import {
+  createProcessingExample,
+  defineRobot,
+  robotBase,
+  robotFileFilteringMeta,
+  robotParameterDocs,
+  robotUse,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 4,
+  ...robotFileFilteringMeta,
   description:
     '/file/verify is a simple Robot that helps ensure that the files you upload are of the type you initially intended. This is especially useful when handling user-generated content, where you may not want to run certain Steps in your Template if the user hasn’t uploaded a file of the correct type. Another use case for /file/verify is when a user uploads a ZIP file, but we find that it has a few damaged files inside when we extract it. Perhaps you don’t want to error out, but only send the good files to a next processing step. With /file/verify, you can do exactly that (assuming the default of `error_on_decline`: `true`).',
-  discount_factor: 0.25,
-  discount_pct: 75,
-  example_code: {
-    steps: {
-      scanned: {
-        robot: '/file/verify',
-        use: ':original',
-        error_on_decline: true,
-        error_msg: 'At least one of the uploaded files was not the desired type',
-        verify_to_be: 'image',
-      },
-    },
-  },
+  example_code: createProcessingExample('scanned', '/file/verify', {
+    error_on_decline: true,
+    error_msg: 'At least one of the uploaded files was not the desired type',
+    verify_to_be: 'image',
+  }),
   example_code_description: 'Scan the uploaded files and throw an error if they are not images:',
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'File Filtering',
   purpose_sentence: 'verifies your files are the type that you want',
   purpose_verb: 'verify',
   purpose_word: 'verify the file type',
   purpose_words: 'Verify the file type',
-  service_slug: 'file-filtering',
-  slot_count: 10,
   title: 'Verify the file type',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'FileVerifyRobot',
   priceFactor: 4,
-  queueSlotCount: 10,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotFileVerifyInstructionsSchema = robotBase
@@ -51,15 +41,11 @@ export const robotFileVerifyInstructionsSchema = robotBase
     error_on_decline: z
       .boolean()
       .default(false)
-      .describe(`
-If this is set to \`true\` and one or more files are declined, the Assembly will be stopped and marked with an error.
-`),
+      .describe(robotParameterDocs.error_on_decline.description),
     error_msg: z
       .string()
       .default('One of your files was declined')
-      .describe(`
-The error message shown to your users (such as by Uppy) when a file is declined and \`error_on_decline\` is set to \`true\`.
-`),
+      .describe(robotParameterDocs.error_msg.description),
     repair_pdf: z
       .boolean()
       .default(false)
@@ -75,34 +61,22 @@ The type that you want to match against to ensure your file is of this type. For
   })
   .strict()
 
-export const robotFileVerifyInstructionsWithHiddenFieldsSchema =
-  robotFileVerifyInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotFileVerifyInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotFileVerifyInstructions = z.infer<typeof robotFileVerifyInstructionsSchema>
-export type RobotFileVerifyInstructionsWithHiddenFields = z.infer<
-  typeof robotFileVerifyInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotFileVerifyInstructionsSchema.shape> =
+  defineRobot(meta, robotFileVerifyInstructionsSchema)
 
-export const interpolatableRobotFileVerifyInstructionsSchema = interpolateRobot(
-  robotFileVerifyInstructionsSchema,
-)
-export type InterpolatableRobotFileVerifyInstructions =
-  InterpolatableRobotFileVerifyInstructionsInput
+export const {
+  withHiddenFields: robotFileVerifyInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotFileVerifyInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotFileVerifyInstructionsInput = z.input<
-  typeof interpolatableRobotFileVerifyInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotFileVerifyInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotFileVerifyInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotFileVerifyInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema
->
+export type RobotFileVerifyInstructions = Instructions['output']
+export type RobotFileVerifyInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotFileVerifyInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotFileVerifyInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotFileVerifyInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotFileVerifyInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/file-virusscan.ts

@@ -1,44 +1,40 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+import {
+  createProcessingExample,
+  defineRobotWithHiddenFields,
+  robotBase,
+  robotFileFilteringMeta,
+  robotParameterDocs,
+  robotUse,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
+  ...robotFileFilteringMeta,
   description:
-    'While 100% security is a myth, having /file/virusscan as a gatekeeper bot helps reject millions of trojans, viruses, malware & other malicious threats before they reach your platform.',
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      scanned: {
-        robot: '/file/virusscan',
-        use: ':original',
-        error_on_decline: true,
-        error_msg: 'At least one of the uploaded files is malicious and was declined',
-      },
-    },
-  },
+    'While 100% security is a myth, having /file/virusscan as a gatekeeper bot helps reject millions of trojans, viruses, malware & other malicious threats before they reach your platform.',
+  example_code: createProcessingExample('scanned', '/file/virusscan', {
+    error_on_decline: true,
+    error_msg: 'At least one of the uploaded files is malicious and was declined',
+  }),
   example_code_description:
     'Scan uploaded files and throw an error if a malicious file is detected:',
-  minimum_charge: 1048576,
   ogimage: '/assets/images/robots/ogimages/file-virusscan.jpg',
-  output_factor: 1,
-  override_lvl1: 'File Filtering',
   purpose_sentence:
-    'rejects millions of trojans, viruses, malware & other malicious threats before they reach your platform',
+    'rejects millions of trojans, viruses, malware & other malicious threats before they reach your platform',
   purpose_verb: 'scan',
   purpose_word: 'scan for viruses and reject malware',
   purpose_words: 'Scan files for viruses',
-  service_slug: 'file-filtering',
-  slot_count: 16,
   title: 'Scan files for viruses',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'FileVirusscanRobot',
-  priceFactor: 1,
   queueSlotCount: 16,
+  preserveInputFileUrls: true,
   minimumCharge: 1048576,
   lazyLoad: true,
   installVersionFile:
@@ -46,17 +42,13 @@ export const meta: RobotMetaInput = {
       ? process.env.API2_CLAMD_INSTALL_VERSION_FILE
       : '',
   isAllowedForUrlTransform: false,
-  trackOutputFileSize: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotFileVirusscanInstructionsSchema = robotBase
   .merge(robotUse)
   .extend({
     robot: z.literal('/file/virusscan').describe(`
-      This <dfn>Robot</dfn> is built on top of [ClamAV](https://www.clamav.net/), the best open source antivirus engine available. We update its signatures on a daily basis.
+This <dfn>Robot</dfn> is built on top of [ClamAV](https://www.clamav.net/), the best open source antivirus engine available. We update its signatures on a daily basis.
 
 By default, this <dfn>Robot</dfn> excludes all malicious files from further processing without any additional notification. This behavior can be changed by setting \`error_on_decline\` to \`true\`, which will stop <dfn>Assemblies</dfn> as soon as malicious files are found. Such <dfn>Assemblies</dfn> will then be marked with an error.
 
@@ -65,52 +57,42 @@ We allow the use of industry standard [EICAR files](https://www.eicar.org/downlo
     error_on_decline: z
       .boolean()
       .default(false)
-      .describe(`
-If this is set to \`true\` and one or more files are declined, the Assembly will be stopped and marked with an error.
-`),
+      .describe(robotParameterDocs.error_on_decline.description),
     error_msg: z
       .string()
       .default('One of your files was declined')
-      .describe(`
-The error message shown to your users (such as by Uppy) when a file is declined and \`error_on_decline\` is set to \`true\`.
-`),
+      .describe(robotParameterDocs.error_msg.description),
   })
   .strict()
 
-export const robotFileVirusscanInstructionsWithHiddenFieldsSchema =
-  robotFileVirusscanInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotFileVirusscanInstructionsSchema.shape.result])
-      .optional(),
-    can_use_daemon_fallback: z
-      .boolean()
-      .optional()
-      .describe(`
+const hiddenFields = {
+  can_use_daemon_fallback: z
+    .boolean()
+    .optional()
+    .describe(`
 Allow the robot to use a daemon fallback mechanism if the primary scanning method fails.
 `),
-  })
+}
 
-export type RobotFileVirusscanInstructions = z.infer<typeof robotFileVirusscanInstructionsSchema>
-export type RobotFileVirusscanInstructionsWithHiddenFields = z.infer<
-  typeof robotFileVirusscanInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotFileVirusscanInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotFileVirusscanInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotFileVirusscanInstructionsSchema = interpolateRobot(
-  robotFileVirusscanInstructionsSchema,
-)
-export type InterpolatableRobotFileVirusscanInstructions =
-  InterpolatableRobotFileVirusscanInstructionsInput
+export const {
+  withHiddenFields: robotFileVirusscanInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotFileVirusscanInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotFileVirusscanInstructionsInput = z.input<
-  typeof interpolatableRobotFileVirusscanInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotFileVirusscanInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema
->
+export type RobotFileVirusscanInstructions = Instructions['output']
+export type RobotFileVirusscanInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotFileVirusscanInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotFileVirusscanInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/file-watermark.ts

@@ -1,43 +1,35 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type { RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+import {
+  createProcessingExample,
+  createRobotSchemaVariants,
+  robotBase,
+  robotImageProcessingMeta,
+  robotUse,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 4,
-  discount_factor: 0.25,
-  discount_pct: 75,
-  example_code: {
-    steps: {
-      watermarked: {
-        robot: '/file/watermark',
-        use: ':original',
-        randomize: true,
-      },
-    },
-  },
+  ...robotImageProcessingMeta,
+  example_code: createProcessingExample('watermarked', '/file/watermark', {
+    randomize: true,
+  }),
   example_code_description: 'Apply randomized watermarking to uploaded files:',
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'Image Manipulation',
+  extended_description: `
+Watermarking is best effort. Unsupported file types, or files that cannot be processed, are returned unchanged. An Assembly can complete successfully without a watermark being applied.
+`,
   purpose_sentence: 'applies randomized watermarks to uploaded media',
   purpose_verb: 'write',
   purpose_word: 'watermark files',
   purpose_words: 'Watermark files',
-  service_slug: 'image-manipulation',
-  slot_count: 20,
   title: 'Apply watermarks to files',
   typical_file_size_mb: 1.2,
   typical_file_type: 'file',
   name: 'FileWatermarkRobot',
   priceFactor: 4,
   queueSlotCount: 20,
-  isAllowedForUrlTransform: true,
   trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotFileWatermarkInstructionsSchema = robotBase
@@ -48,34 +40,23 @@ export const robotFileWatermarkInstructionsSchema = robotBase
   })
   .strict()
 
-export const robotFileWatermarkInstructionsWithHiddenFieldsSchema =
-  robotFileWatermarkInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotFileWatermarkInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotFileWatermarkInstructions = z.infer<typeof robotFileWatermarkInstructionsSchema>
-export type RobotFileWatermarkInstructionsWithHiddenFields = z.infer<
-  typeof robotFileWatermarkInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotFileWatermarkInstructionsSchema = interpolateRobot(
-  robotFileWatermarkInstructionsSchema,
-)
-export type InterpolatableRobotFileWatermarkInstructions =
-  InterpolatableRobotFileWatermarkInstructionsInput
-
-export type InterpolatableRobotFileWatermarkInstructionsInput = z.input<
-  typeof interpolatableRobotFileWatermarkInstructionsSchema
->
-
-export const interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotFileWatermarkInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema
->
+const schemaVariants: ReturnType<
+  typeof createRobotSchemaVariants<typeof robotFileWatermarkInstructionsSchema.shape>
+> = createRobotSchemaVariants(robotFileWatermarkInstructionsSchema)
+export const {
+  withHiddenFields: robotFileWatermarkInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotFileWatermarkInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema,
+} = schemaVariants
+
+type Instructions = RobotSchemaVariantTypes<typeof schemaVariants>
+
+export type RobotFileWatermarkInstructions = Instructions['output']
+export type RobotFileWatermarkInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotFileWatermarkInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotFileWatermarkInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,51 +1,32 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
+  createStorageImportExample,
+  defineRobot,
   ftpBase,
-  interpolateRobot,
   path,
   robotBase,
   robotImport,
+  robotImportMeta,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
-  example_code: {
-    steps: {
-      imported: {
-        robot: '/ftp/import',
-        credentials: 'YOUR_FTP_CREDENTIALS',
-        path: 'path/to/files/',
-      },
-    },
-  },
+  ...robotImportMeta,
+  example_code: createStorageImportExample('/ftp/import', 'YOUR_FTP_CREDENTIALS', false),
   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 FTP servers into Transloadit. This Robot relies on password access. For more security, consider our /sftp/import Robot',
-  purpose_verb: 'import',
   purpose_word: 'FTP servers',
   purpose_words: 'Import files from FTP servers',
-  service_slug: 'file-importing',
-  slot_count: 20,
   title: 'Import files from FTP servers',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'FtpImportRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 20,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-  stage: 'ga',
 }
 
 export const robotFtpImportInstructionsSchema = robotBase
@@ -65,31 +46,22 @@ Determines if passive mode should be used for the FTP connection.
   })
   .strict()
 
-export const robotFtpImportInstructionsWithHiddenFieldsSchema =
-  robotFtpImportInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotFtpImportInstructionsSchema.shape.result]).optional(),
-  })
-
-export type RobotFtpImportInstructions = z.infer<typeof robotFtpImportInstructionsSchema>
-export type RobotFtpImportInstructionsWithHiddenFields = z.infer<
-  typeof robotFtpImportInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotFtpImportInstructionsSchema.shape> =
+  defineRobot(meta, robotFtpImportInstructionsSchema)
 
-export const interpolatableRobotFtpImportInstructionsSchema = interpolateRobot(
-  robotFtpImportInstructionsSchema,
-)
-export type InterpolatableRobotFtpImportInstructions = InterpolatableRobotFtpImportInstructionsInput
+export const {
+  withHiddenFields: robotFtpImportInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotFtpImportInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotFtpImportInstructionsInput = z.input<
-  typeof interpolatableRobotFtpImportInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotFtpImportInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotFtpImportInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotFtpImportInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema
->
+export type RobotFtpImportInstructions = Instructions['output']
+export type RobotFtpImportInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotFtpImportInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotFtpImportInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotFtpImportInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotFtpImportInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,45 +1,30 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { ftpBase, interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+import {
+  createStorageStoreExample,
+  defineRobotWithHiddenFields,
+  ftpBase,
+  robotBase,
+  robotStoreMeta,
+  robotUse,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 6,
-  discount_factor: 0.15000150001500018,
-  discount_pct: 84.99984999849998,
-  example_code: {
-    steps: {
-      exported: {
-        robot: '/ftp/store',
-        use: ':original',
-        credentials: 'YOUR_FTP_CREDENTIALS',
-        path: 'my_target_folder/${unique_prefix}/${file.url_name}',
-      },
-    },
-  },
+  ...robotStoreMeta,
+  example_code: createStorageStoreExample('/ftp/store', 'YOUR_FTP_CREDENTIALS'),
   example_code_description: 'Export uploaded files to `my_target_folder` on an FTP server:',
-  minimum_charge: 0,
-  output_factor: 1,
-  override_lvl1: 'File Exporting',
   purpose_sentence:
     'exports encoding results to your FTP servers. This Robot relies on password access. For more security, consider our /sftp/store Robot',
-  purpose_verb: 'export',
   purpose_word: 'FTP servers',
   purpose_words: 'Export files to FTP servers',
-  service_slug: 'file-exporting',
-  slot_count: 10,
   title: 'Export files to FTP servers',
-  typical_file_size_mb: 1.2,
-  typical_file_type: 'file',
   name: 'FtpStoreRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 10,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotFtpStoreInstructionsSchema = robotBase
@@ -76,44 +61,40 @@ Determines whether to establish a secure connection to the FTP server using SSL.
   })
   .strict()
 
-export const robotFtpStoreInstructionsWithHiddenFieldsSchema =
-  robotFtpStoreInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotFtpStoreInstructionsSchema.shape.result]).optional(),
-    use_remote_utime: z
-      .boolean()
-      .optional()
-      .describe(`
+const hiddenFields = {
+  use_remote_utime: z
+    .boolean()
+    .optional()
+    .describe(`
 Use the remote file's modification time instead of the current time when storing the file.
 `),
-    version: z
-      .union([z.string(), z.number()])
-      .optional()
-      .describe(`
+  version: z
+    .union([z.string(), z.number()])
+    .optional()
+    .describe(`
 Version identifier for the underlying tool used (2 is ncftp, 1 is ftp).
 `),
-    allowNetwork: z.string().optional(), // For internal test purposes
-  })
+  allowNetwork: z.string().optional(), // For internal test purposes
+}
 
-export type RobotFtpStoreInstructions = z.infer<typeof robotFtpStoreInstructionsSchema>
-export type RobotFtpStoreInstructionsWithHiddenFields = z.infer<
-  typeof robotFtpStoreInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotFtpStoreInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotFtpStoreInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotFtpStoreInstructionsSchema = interpolateRobot(
-  robotFtpStoreInstructionsSchema,
-)
-export type InterpolatableRobotFtpStoreInstructions = InterpolatableRobotFtpStoreInstructionsInput
+export const {
+  withHiddenFields: robotFtpStoreInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotFtpStoreInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotFtpStoreInstructionsInput = z.input<
-  typeof interpolatableRobotFtpStoreInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotFtpStoreInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotFtpStoreInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotFtpStoreInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema
->
+export type RobotFtpStoreInstructions = Instructions['output']
+export type RobotFtpStoreInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotFtpStoreInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotFtpStoreInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotFtpStoreInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotFtpStoreInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']