@transloadit/node 4.7.6 → 4.7.7

package/src/alphalib/types/robots/image-enhance.ts

@@ -0,0 +1,185 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  imageQualitySchema,
+  interpolateRobot,
+  robotBase,
+  robotImagemagick,
+  robotUse,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      enhanced_classic: {
+        robot: '/image/enhance',
+        use: ':original',
+        enhance: 'auto',
+        preset: 'vivid',
+      },
+      enhanced_ai: {
+        robot: '/image/enhance',
+        use: ':original',
+        engine: 'ai',
+        ai_preset: 'restore',
+      },
+    },
+  },
+  example_code_description: 'Enhance uploaded images with classic auto mode or AI restoration:',
+  minimum_charge: 0,
+  output_factor: 0.6,
+  override_lvl1: 'Image Manipulation',
+  purpose_sentence:
+    'automatically enhances images by adjusting levels, contrast, and sharpness, and optionally applies photo filter presets',
+  purpose_verb: 'enhance',
+  purpose_word: 'enhance',
+  purpose_words: 'Enhance images',
+  service_slug: 'image-manipulation',
+  slot_count: 15,
+  title: 'Enhance images',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'image',
+  name: 'ImageEnhanceRobot',
+  priceFactor: 1,
+  queueSlotCount: 15,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'beta',
+}
+
+const enhanceModeSchema = z.enum(['auto', 'auto_gentle', 'auto_aggressive', 'none']).default('auto')
+
+const presetSchema = z
+  .enum([
+    'none',
+    'warm',
+    'cool',
+    'vintage',
+    'vivid',
+    'matte',
+    'cinematic',
+    'golden_hour',
+    'bw_dramatic',
+    'bw_classic',
+    'noir',
+    'fade',
+    'pastel',
+    'teal_orange',
+  ])
+  .default('none')
+
+const engineSchema = z.enum(['classic', 'ai']).default('classic')
+
+const aiPresetSchema = z.enum(['restore', 'face_restore']).default('restore')
+
+export const robotImageEnhanceInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotImagemagick)
+  .extend({
+    robot: z.literal('/image/enhance').describe(`
+With this <dfn>Robot</dfn> you can automatically enhance images with one click — adjusting levels, contrast, saturation, sharpness, and white balance to produce an optimally balanced image. It also supports a library of named photo filter presets (e.g. \`warm\`, \`cool\`, \`vintage\`, \`vivid\`) that apply curated color grading and tone adjustments.
+
+It works well together with [🤖/image/resize](/docs/robots/image-resize/) — you can enhance first, then resize, or vice versa.
+
+> [!Note]
+> This <dfn>Robot</dfn> accepts all image types supported by ImageMagick and will pass through unsupported types unchanged.
+
+> [!Note]
+> \`engine: "classic"\` uses \`enhance\`, \`preset\`, \`sharpen\`, and \`denoise\`. \`engine: "ai"\` uses \`ai_preset\` and \`quality\`; classic controls are ignored in AI mode.
+
+> [!Note]
+> Output keeps the original file extension when possible. In AI mode, if the target extension is not writable by the selected \`imagemagick_stack\`, the file is passed through unchanged.
+`),
+    enhance: enhanceModeSchema.describe(`
+The auto-enhancement mode. \`"auto"\` applies balanced auto-levels, gamma correction, and subtle sharpening. \`"auto_gentle"\` is more conservative (good for already-decent photos). \`"auto_aggressive"\` applies stronger normalization and contrast. \`"none"\` skips auto-enhance (useful when only applying a preset filter).
+`),
+    preset: presetSchema.describe(`
+A named color grading preset to apply. Applied after auto-enhancement. Use \`"none"\` to skip preset application.
+
+Available presets:
+- \`warm\` — Warm golden tones
+- \`cool\` — Cool blue-shifted tones
+- \`vintage\` — Faded retro look with warm shadows
+- \`vivid\` — Boosted saturation and contrast
+- \`matte\` — Lifted blacks for a matte film look
+- \`cinematic\` — Teal-and-orange cinema grading
+- \`golden_hour\` — Warm sunset-like glow
+- \`bw_dramatic\` — High-contrast black and white
+- \`bw_classic\` — Classic film black and white
+- \`noir\` — Dark, moody black and white
+- \`fade\` — Washed-out faded look
+- \`pastel\` — Soft, desaturated pastel tones
+- \`teal_orange\` — Complementary teal shadows and orange highlights
+`),
+    engine: engineSchema.describe(`
+Enhancement engine to use.
+
+- \`"classic"\` uses ImageMagick-based adjustments and presets.
+- \`"ai"\` uses AI restoration models on Replicate (typically higher latency and cost than classic mode).
+`),
+    ai_preset: aiPresetSchema.describe(`
+AI enhancement preset used when \`engine\` is set to \`"ai"\`:
+- \`restore\` — General image restoration.
+- \`face_restore\` — Portrait-focused face restoration.
+
+AI mode is not intended for image upscaling. For dedicated upscaling, use [🤖/image/upscale](/docs/robots/image-upscale/).
+`),
+    sharpen: z
+      .number()
+      .min(0)
+      .max(10)
+      .default(0)
+      .describe(`
+Additional sharpening amount (\`0\` = none, \`10\` = maximum). The \`"auto"\` enhance mode already applies subtle sharpening; this parameter adds more on top.
+`),
+    denoise: z
+      .number()
+      .min(0)
+      .max(10)
+      .default(0)
+      .describe(`
+Noise reduction strength (\`0\` = none, \`10\` = maximum). Useful for high-ISO photos.
+`),
+    quality: imageQualitySchema.describe(`
+Quality of the output image. A value between \`1\` and \`100\`. Defaults to \`92\`.
+`),
+  })
+  .strict()
+
+export const robotImageEnhanceInstructionsWithHiddenFieldsSchema =
+  robotImageEnhanceInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotImageEnhanceInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageEnhanceInstructions = z.infer<typeof robotImageEnhanceInstructionsSchema>
+export type RobotImageEnhanceInstructionsWithHiddenFields = z.infer<
+  typeof robotImageEnhanceInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageEnhanceInstructionsSchema = interpolateRobot(
+  robotImageEnhanceInstructionsSchema,
+)
+export type InterpolatableRobotImageEnhanceInstructions =
+  InterpolatableRobotImageEnhanceInstructionsInput
+
+export type InterpolatableRobotImageEnhanceInstructionsInput = z.input<
+  typeof interpolatableRobotImageEnhanceInstructionsSchema
+>
+
+export const interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotImageEnhanceInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema
+>

package/src/alphalib/types/robots/image-facedetect.ts

@@ -9,7 +9,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,

package/src/alphalib/types/robots/image-generate.ts

@@ -4,10 +4,29 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,
+  example_code: {
+    steps: {
+      ':original': {
+        robot: '/upload/handle',
+      },
+      inpainted: {
+        robot: '/image/generate',
+        use: [
+          { name: ':original', as: 'image' },
+          { name: ':original', as: 'mask' },
+        ],
+        model: 'google/nano-banana-pro',
+        prompt:
+          'Replace the masked area with a breaching whale. Keep the rest of the image unchanged.',
+        format: 'png',
+      },
+    },
+  },
+  example_code_description:
+    'Inpaint an image by uploading an original image and a mask image, then use both files in /image/generate.',
   minimum_charge: 0,
   output_factor: 0.6,
   purpose_sentence: 'generates images from text prompts using AI',
@@ -30,23 +49,70 @@ export const meta: RobotMetaInput = {
   stage: 'ga',
 }
 
+// Internal documentation (for public docs, see transloadit.com/docs)
+//
+// Inpainting: When input files are provided via `use`, file metadata (field name, mime) is
+// prepended to the prompt so the model understands each file's role. Users should name upload
+// fields semantically (e.g., "mask", "image") or use the `as` directive. Field is checked first,
+// then `as`. Models that accept explicit image/mask inputs use these roles deterministically.
+// Models that infer roles from prompt context receive this file metadata in the prompt.
 export const robotImageGenerateInstructionsSchema = robotBase
   .merge(robotUse)
   .extend({
     robot: z.literal('/image/generate'),
+    use: robotUse.shape.use.describe(
+      `
+Specifies which Step(s) to use as input.
+
+For inpainting, provide both the source image and mask through \`use\`, typically with:
+
+\`\`\`json
+{
+  "use": [
+    { "name": ":original", "as": "image" },
+    { "name": ":original", "as": "mask" }
+  ]
+}
+\`\`\`
+
+Best practice:
+- Tag source and mask inputs explicitly using \`as\` (or semantic upload field names)
+- Keep the prompt focused on what should change in the masked/transparent region
+- Leave the model/provider choice to the robot defaults unless you have a specific need
+`,
+    ),
     model: z
       .string()
       .optional()
-      .describe('The AI model to use for image generation. Defaults to google/nano-banana.'),
-    prompt: z.string().describe('The prompt describing the desired image content.'),
+      .describe(
+        'The AI model to use. Defaults to google/nano-banana. Supported models include flux-1.1-pro-ultra, flux-schnell, recraft-v3, google/nano-banana, google/nano-banana-2, google/nano-banana-pro, and stability-ai/stable-diffusion-inpainting.',
+      ),
+    prompt: z
+      .string()
+      .describe(
+        'Prompt describing the desired image. For inpainting, describe what should appear in the masked/transparent region and that the rest should stay unchanged.',
+      ),
     format: z
       .enum(['jpeg', 'jpg', 'png', 'gif', 'webp', 'svg'])
       .optional()
-      .describe('Format of the generated image.'),
+      .describe(
+        'Output format. Defaults depend on model: png for Google models, svg for recraft-v3, jpeg for others. Google models currently return PNG only.',
+      ),
     seed: z.number().optional().describe('Seed for the random number generator.'),
-    aspect_ratio: z.string().optional().describe('Aspect ratio of the generated image.'),
-    height: z.number().optional().describe('Height of the generated image.'),
-    width: z.number().optional().describe('Width of the generated image.'),
+    aspect_ratio: z
+      .string()
+      .optional()
+      .describe(
+        'Requested output aspect ratio. For Google models, width/height can also be used and orientation is derived automatically when aspect_ratio is omitted.',
+      ),
+    height: z
+      .number()
+      .optional()
+      .describe('Requested output height in pixels (mainly used by Google image models).'),
+    width: z
+      .number()
+      .optional()
+      .describe('Requested output width in pixels (mainly used by Google image models).'),
     style: z.string().optional().describe('Style of the generated image.'),
     num_outputs: z
       .number()
@@ -54,7 +120,7 @@ export const robotImageGenerateInstructionsSchema = robotBase
       .min(1)
       .max(10)
       .optional()
-      .describe('Number of image variants to generate.'),
+      .describe('Number of output variants to generate (1-10).'),
   })
   .strict()
 

package/src/alphalib/types/robots/image-merge.ts

@@ -10,7 +10,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,

package/src/alphalib/types/robots/image-ocr.ts

@@ -10,7 +10,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,

package/src/alphalib/types/robots/image-optimize.ts

@@ -9,7 +9,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,
@@ -30,13 +29,13 @@ export const meta: RobotMetaInput = {
   purpose_word: 'optimize',
   purpose_words: 'Optimize images without quality loss',
   service_slug: 'image-manipulation',
-  slot_count: 15,
+  slot_count: 5,
   title: 'Optimize images without quality loss',
   typical_file_size_mb: 0.8,
   typical_file_type: 'image',
   name: 'ImageOptimizeRobot',
   priceFactor: 1,
-  queueSlotCount: 15,
+  queueSlotCount: 5,
   isAllowedForUrlTransform: true,
   trackOutputFileSize: true,
   isInternal: false,
@@ -56,6 +55,9 @@ It works well together with [🤖/image/resize](/docs/robots/image-resize/) to b
 
 > [!Note]
 > This <dfn>Robot</dfn> accepts all image types and will just pass on unsupported image types unoptimized. Hence, there is no need to set up [🤖/file/filter](/docs/robots/file-filter/) workflows for this.
+
+> [!Note]
+> PNG optimization uses only lossless (optipng) compressors by default. To also enable lossy compression (pngquant), set \`lossy: true\`. When enabled, both lossy and lossless compressors compete and the smallest result wins, which may cause color shifts in some images.
 `),
     priority: optimize_priority.describe(`
 Provides different algorithms for better or worse compression for your images, but that run slower or faster. The value \`"conversion-speed"\` will result in an average compression ratio of 18%. \`"compression-ratio"\` will result in an average compression ratio of 31%.
@@ -77,6 +79,17 @@ Specifies if the image's metadata should be preserved during the optimization, o
       .default(true)
       .describe(`
 If set to \`true\` this parameter tries to fix images that would otherwise make the underlying tool error out and thereby break your <dfn>Assemblies</dfn>. This can sometimes result in a larger file size, though.
+`),
+    lossy: z
+      .boolean()
+      .default(false)
+      .describe(`
+When set to \`false\` (the default), only lossless PNG optimizers are used, disabling pngquant to preserve color accuracy.
+
+When set to \`true\`, both lossy and lossless PNG optimizers compete and the smallest result wins. This allows pngquant, a lossy compressor that reduces PNGs to a 256-color palette, which may cause noticeable color shifts in images with rich color palettes, subtle gradients, or brand-specific colors.
+
+> [!Note]
+> This parameter only affects PNG optimization. JPEG, GIF, WebP, and SVG optimization is unaffected.
 `),
   })
   .strict()

package/src/alphalib/types/robots/image-resize.ts

@@ -17,7 +17,6 @@ import {
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  allowed_for_url_transform: true,
   bytescount: 1,
   discount_factor: 1,
   discount_pct: 0,
@@ -545,6 +544,43 @@ Apply the clipping path to other operations in the resize job, if one is present
       .default(false)
       .describe(`
 Replace each pixel with its complementary color, effectively negating the image. Especially useful when testing clipping.
+`),
+    clut: z
+      .boolean()
+      .default(false)
+      .describe(`
+Applies a Color Look-Up Table (CLUT) image to remap the colors of the input image using ImageMagick's \`-clut\` operator. When enabled, a second input file must be supplied via the \`use\` parameter with \`"as": "clut"\`.
+
+This operation currently runs via ImageMagick convert stack (not image-resizer daemon), even if \`stack: "daemon"\` is requested.
+
+When using multiple inputs, you should provide your primary image as \`"as": "base"\`. If no explicit \`base\` alias is set, Transloadit will use the first non-auxiliary input (a file that is not tagged as \`watermark\` or \`clut\`) as the primary image.
+
+The CLUT image acts as a gradient map: each pixel's color channels in the input are replaced with the corresponding color from the CLUT image, based on channel intensity. This is a powerful color grading technique widely used in photography and design workflows.
+
+Example:
+
+\`\`\`json
+{
+  "steps": {
+    ":original": {
+      "robot": "/upload/handle"
+    },
+    "lut_image": {
+      "robot": "/upload/handle"
+    },
+    "color_graded": {
+      "robot": "/image/resize",
+      "use": {
+        "steps": [
+          { "name": ":original", "as": "base" },
+          { "name": "lut_image", "as": "clut" }
+        ]
+      },
+      "clut": true
+    }
+  }
+}
+\`\`\`
 `),
     density: z
       .string()

package/src/alphalib/types/robots/image-upscale.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      upscaled: {
+        robot: '/image/upscale',
+        use: ':original',
+        scale: 2,
+        face_enhance: true,
+      },
+    },
+  },
+  example_code_description: 'Upscale uploaded images and enhance faces:',
+  minimum_charge: 0,
+  output_factor: 0.6,
+  purpose_sentence: 'upscales images using AI',
+  purpose_verb: 'generate',
+  purpose_word: 'upscale',
+  purpose_words: 'Upscale images',
+  service_slug: 'artificial-intelligence',
+  slot_count: 10,
+  title: 'Upscale images',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'image',
+  name: 'ImageUpscaleRobot',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  minimumChargeUsd: 0.06,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'beta',
+}
+
+export const robotImageUpscaleInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/upscale'),
+    model: z
+      .enum(['nightmareai/real-esrgan', 'tencentarc/gfpgan', 'sczhou/codeformer'])
+      .optional()
+      .describe('The AI model to use for image upscaling. Defaults to nightmareai/real-esrgan.'),
+    scale: z
+      .union([z.literal(2), z.literal(4)])
+      .optional()
+      .describe('Upscale factor. Defaults to 2.'),
+    face_enhance: z
+      .boolean()
+      .optional()
+      .describe('Enable face enhancement for better face restoration. Defaults to false.'),
+  })
+  .strict()
+
+export const robotImageUpscaleInstructionsWithHiddenFieldsSchema =
+  robotImageUpscaleInstructionsSchema.extend({
+    provider: z.string().optional().describe('Provider for upscaling the image.'),
+    result: z
+      .union([z.literal('debug'), robotImageUpscaleInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageUpscaleInstructions = z.infer<typeof robotImageUpscaleInstructionsSchema>
+export type RobotImageUpscaleInstructionsWithHiddenFields = z.infer<
+  typeof robotImageUpscaleInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageUpscaleInstructionsSchema = interpolateRobot(
+  robotImageUpscaleInstructionsSchema,
+)
+export type InterpolatableRobotImageUpscaleInstructions =
+  InterpolatableRobotImageUpscaleInstructionsInput
+
+export type InterpolatableRobotImageUpscaleInstructionsInput = z.input<
+  typeof interpolatableRobotImageUpscaleInstructionsSchema
+>
+
+export const interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotImageUpscaleInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,123 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  files_per_page,
+  interpolateRobot,
+  megaBase,
+  page_number,
+  path,
+  recursive,
+  return_file_stubs,
+  robotBase,
+  robotImport,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  example_code: {
+    steps: {
+      imported: {
+        robot: '/mega/import',
+        credentials: 'YOUR_MEGA_CREDENTIALS',
+        path: 'path/to/files/',
+        recursive: true,
+      },
+    },
+  },
+  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 MEGA object storage bucket',
+  purpose_verb: 'import',
+  purpose_word: 'MEGA',
+  purpose_words: 'Import files from MEGA',
+  requires_credentials: true,
+  service_slug: 'file-importing',
+  slot_count: 20,
+  title: 'Import files from MEGA',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+  name: 'MegaImportRobot',
+  priceFactor: 6.6666,
+  queueSlotCount: 20,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: false,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+  stage: 'ga',
+}
+
+export const robotMegaImportInstructionsSchema = robotBase
+  .merge(robotImport)
+  .merge(megaBase)
+  .extend({
+    result: z
+      .boolean()
+      .optional()
+      .describe('Whether the results of this Step should be present in the Assembly Status JSON'),
+    robot: z.literal('/mega/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 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.
+`),
+    return_file_stubs,
+  })
+  .strict()
+
+export const robotMegaImportInstructionsWithHiddenFieldsSchema =
+  robotMegaImportInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotMegaImportInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotMegaImportInstructions = z.infer<typeof robotMegaImportInstructionsSchema>
+export type RobotMegaImportInstructionsWithHiddenFields = z.infer<
+  typeof robotMegaImportInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotMegaImportInstructionsSchema = interpolateRobot(
+  robotMegaImportInstructionsSchema,
+)
+export type InterpolatableRobotMegaImportInstructions =
+  InterpolatableRobotMegaImportInstructionsInput
+
+export type InterpolatableRobotMegaImportInstructionsInput = z.input<
+  typeof interpolatableRobotMegaImportInstructionsSchema
+>
+
+export const interpolatableRobotMegaImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotMegaImportInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotMegaImportInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotMegaImportInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotMegaImportInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotMegaImportInstructionsWithHiddenFieldsSchema
+>