@transloadit/node 4.1.3

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

@@ -0,0 +1,121 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  aiProviderSchema,
+  granularitySchema,
+  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: {
+      described: {
+        robot: '/image/describe',
+        use: ':original',
+        provider: 'aws',
+      },
+    },
+  },
+  example_code_description:
+    'Recognize objects in an uploaded image and store the labels in a JSON file:',
+  extended_description: `
+> [!Warning]
+> Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses third-party AI services. The providers (AWS, GCP) will evolve their models over time, giving different responses for the same input images. Avoid relying on exact responses in your tests and application.
+`,
+  minimum_charge: 1572864,
+  output_factor: 0.05,
+  override_lvl1: 'Artificial Intelligence',
+  purpose_sentence: 'recognizes objects in images and returns them as English words',
+  purpose_verb: 'recognize',
+  purpose_word: 'recognize objects',
+  purpose_words: 'Recognize objects in images',
+  service_slug: 'artificial-intelligence',
+  slot_count: 10,
+  title: 'Recognize objects in images',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+  name: 'ImageDescribeRobot',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  minimumChargeUsd: 0.0013,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotImageDescribeInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/describe').describe(`
+You can use the labels that we return in your application to automatically classify images. You can also pass the labels down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain content.
+`),
+    provider: aiProviderSchema.optional().describe(`
+Which AI provider to leverage.
+
+Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+`),
+    granularity: granularitySchema.describe(`
+Whether to return a full response (\`"full"\`) including confidence percentages for each found label, or just a flat list of labels (\`"list"\`).
+`),
+    format: z
+      .enum(['json', 'meta', 'text'])
+      .default('json')
+      .describe(`
+In what format to return the descriptions.
+
+- \`"json"\` returns a JSON file.
+- \`"meta"\` does not return a file, but stores the data inside Transloadit's file object (under \`\${file.meta.descriptions}\`) that's passed around between encoding <dfn>Steps</dfn>, so that you can use the values to burn the data into videos, filter on them, etc.
+`),
+    explicit_descriptions: z
+      .boolean()
+      .default(false)
+      .describe(`
+Whether to return only explicit or only non-explicit descriptions of the provided image. Explicit descriptions include labels for NSFW content (nudity, violence, etc). If set to \`false\`, only non-explicit descriptions (such as human or chair) will be returned. If set to \`true\`, only explicit descriptions will be returned.
+
+The possible descriptions depend on the chosen provider. The list of labels from AWS can be found [in their documentation](https://docs.aws.amazon.com/rekognition/latest/dg/moderation.html#moderation-api). GCP labels the image based on five categories, as described [in their documentation](https://cloud.google.com/vision/docs/detecting-safe-search).
+
+For an example of how to automatically reject NSFW content and malware, please check out this [blog post](/blog/2022/07/deny-image-uploads/).
+`),
+  })
+  .strict()
+
+export const robotImageDescribeInstructionsWithHiddenFieldsSchema =
+  robotImageDescribeInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotImageDescribeInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageDescribeInstructions = z.infer<typeof robotImageDescribeInstructionsSchema>
+export type RobotImageDescribeInstructionsWithHiddenFields = z.infer<
+  typeof robotImageDescribeInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageDescribeInstructionsSchema = interpolateRobot(
+  robotImageDescribeInstructionsSchema,
+)
+export type InterpolatableRobotImageDescribeInstructions =
+  InterpolatableRobotImageDescribeInstructionsInput
+
+export type InterpolatableRobotImageDescribeInstructionsInput = z.input<
+  typeof interpolatableRobotImageDescribeInstructionsSchema
+>
+
+export const interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotImageDescribeInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageDescribeInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageDescribeInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,187 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  aiProviderSchema,
+  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: {
+      faces_detected: {
+        robot: '/image/facedetect',
+        use: ':original',
+        crop: true,
+        faces: 'each',
+        crop_padding: '10px',
+      },
+    },
+  },
+  example_code_description:
+    'Detect all faces in uploaded images, crop them, and save as separate images:',
+  minimum_charge: 5242880,
+  output_factor: 0.2,
+  override_lvl1: 'Artificial Intelligence',
+  purpose_sentence:
+    'detects faces in images and can return either their coordinates or the faces themselves as new images',
+  purpose_verb: 'detect',
+  purpose_word: 'detect faces',
+  purpose_words: 'Detect faces in images',
+  service_slug: 'artificial-intelligence',
+  slot_count: 20,
+  title: 'Detect faces in images',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+  name: 'ImageFacedetectRobot',
+  priceFactor: 1,
+  queueSlotCount: 20,
+  minimumChargeUsd: 0.0013,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotImageFacedetectInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/facedetect').describe(`
+You can specify padding around the extracted faces, tailoring the output for your needs.
+
+This <dfn>Robot</dfn> works well together with [🤖/image/resize](/docs/robots/image-resize/) to bring the full power of resized and optimized images to your website or app.
+
+<div class="alert alert-note">
+
+**How to improve the accuracy:**
+
+- Ensure that your pictures have the correct orientation. This <dfn>Robot</dfn> achieves the best performance when the faces in the image are oriented upright and not rotated.
+- If the <dfn>Robot</dfn> detects objects other than a face, you can use \`"faces": "max-confidence"\` within your <dfn>Template</dfn> for selecting only the detection with the highest confidence.
+- The number of returned detections can also be controlled using the \`min_confidence\` parameter. Increasing its value will yield less results but each with a higher confidence. Decreasing the value, on the other hand, will provide more results but may also include objects other than faces.
+
+</div>
+`),
+    provider: aiProviderSchema.optional().describe(`
+Which AI provider to leverage.
+
+Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+`),
+    crop: z
+      .boolean()
+      .default(false)
+      .describe(`
+Determine if the detected faces should be extracted. If this option is set to \`false\`, then the <dfn>Robot</dfn> returns the input image again, but with the coordinates of all detected faces attached to \`file.meta.faces\` in the result JSON. If this parameter is set to \`true\`, the <dfn>Robot</dfn> will output all detected faces as images.
+`),
+    crop_padding: z
+      .string()
+      .regex(/^\d+(px|%)$/)
+      .default('5px')
+      .describe(`
+Specifies how much padding is added to the extracted face images if \`crop\` is set to \`true\`. Values can be in \`px\` (pixels) or \`%\` (percentage of the width and height of the particular face image).
+`),
+    format: z
+      .enum(['jpg', 'png', 'preserve', 'tiff'])
+      .default('preserve')
+      .describe(`
+Determines the output format of the extracted face images if \`crop\` is set to \`true\`.
+
+The default value \`"preserve"\` means that the input image format is re-used.
+`),
+    min_confidence: z
+      .number()
+      .int()
+      .min(0)
+      .max(100)
+      .default(70)
+      .describe(`
+Specifies the minimum confidence that a detected face must have. Only faces which have a higher confidence value than this threshold will be included in the result.
+`),
+    faces: z
+      .union([z.enum(['each', 'group', 'max-confidence', 'max-size']), z.number().int()])
+      .default('each')
+      .describe(`
+Determines which of the detected faces should be returned. Valid values are:
+
+- \`"each"\` — each face is returned individually.
+- \`"max-confidence"\` — only the face with the highest confidence value is returned.
+- \`"max-size"\` — only the face with the largest area is returned.
+- \`"group"\` — all detected faces are grouped together into one rectangle that contains all faces.
+- any integer — the faces are sorted by their top-left corner and the integer determines the index of the returned face. Be aware the values are zero-indexed, meaning that \`faces: 0\` will return the first face. If no face for a given index exists, no output is produced.
+
+For the following examples, the input image is:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-unsplash.jpg)
+
+<br>
+
+\`faces: "each"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-0.jpg)
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
+
+<br>
+
+\`faces: "max-confidence"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
+
+<br>
+
+\`faces: "max-size"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
+
+<br>
+
+\`faces: "group"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-group.jpg)
+
+<br>
+
+\`faces: 0\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-0.jpg)
+`),
+  })
+  .strict()
+
+export const robotImageFacedetectInstructionsWithHiddenFieldsSchema =
+  robotImageFacedetectInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotImageFacedetectInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageFacedetectInstructions = z.infer<
+  typeof robotImageFacedetectInstructionsSchema
+>
+export type RobotImageFacedetectInstructionsWithHiddenFields = z.infer<
+  typeof robotImageFacedetectInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageFacedetectInstructionsSchema = interpolateRobot(
+  robotImageFacedetectInstructionsSchema,
+)
+export type InterpolatableRobotImageFacedetectInstructions =
+  InterpolatableRobotImageFacedetectInstructionsInput
+
+export type InterpolatableRobotImageFacedetectInstructionsInput = z.input<
+  typeof interpolatableRobotImageFacedetectInstructionsSchema
+>
+
+export const interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema =
+  interpolateRobot(robotImageFacedetectInstructionsWithHiddenFieldsSchema)
+export type InterpolatableRobotImageFacedetectInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageFacedetectInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,92 @@
+import { z } from 'zod'
+
+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,
+  minimum_charge: 0,
+  output_factor: 0.6,
+  purpose_sentence: 'generates images from text prompts using AI',
+  purpose_verb: 'generate',
+  purpose_word: 'generate',
+  purpose_words: 'Generate images from text prompts',
+  service_slug: 'artificial-intelligence',
+  slot_count: 10,
+  title: 'Generate images from text prompts',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'image',
+  name: 'ImageGenerateRobot',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  minimumChargeUsd: 0.06,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotImageGenerateInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/generate'),
+    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.'),
+    format: z
+      .enum(['jpeg', 'jpg', 'png', 'gif', 'webp', 'svg'])
+      .optional()
+      .describe('Format of the generated image.'),
+    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.'),
+    style: z.string().optional().describe('Style of the generated image.'),
+    num_outputs: z
+      .number()
+      .int()
+      .min(1)
+      .max(10)
+      .optional()
+      .describe('Number of image variants to generate.'),
+  })
+  .strict()
+
+export const robotImageGenerateInstructionsWithHiddenFieldsSchema =
+  robotImageGenerateInstructionsSchema.extend({
+    provider: z.string().optional().describe('Provider for generating the image.'),
+    result: z
+      .union([z.literal('debug'), robotImageGenerateInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageGenerateInstructions = z.infer<typeof robotImageGenerateInstructionsSchema>
+export type RobotImageGenerateInstructionsWithHiddenFields = z.infer<
+  typeof robotImageGenerateInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageGenerateInstructionsSchema = interpolateRobot(
+  robotImageGenerateInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageGenerateInstructions =
+  InterpolatableRobotImageGenerateInstructionsInput
+
+export type InterpolatableRobotImageGenerateInstructionsInput = z.input<
+  typeof interpolatableRobotImageGenerateInstructionsSchema
+>
+
+export const interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotImageGenerateInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageGenerateInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageGenerateInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,127 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  color_without_alpha,
+  imageQualitySchema,
+  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: {
+      merged: {
+        robot: '/image/merge',
+        use: {
+          steps: [':original'],
+          bundle_steps: true,
+        },
+        border: 5,
+      },
+    },
+  },
+  example_code_description:
+    'Merge uploaded images into one, with a 5px gap between them on the spritesheet:',
+  minimum_charge: 0,
+  output_factor: 0.6,
+  override_lvl1: 'Image Manipulation',
+  purpose_sentence: 'merges several images into a single spritesheet',
+  purpose_verb: 'merge',
+  purpose_word: 'merge',
+  purpose_words: 'Merge several images into one image',
+  service_slug: 'image-manipulation',
+  slot_count: 10,
+  title: 'Merge several images into a single image',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+  name: 'ImageMergeRobot',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  isAllowedForUrlTransform: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotImageMergeInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/merge').describe(`
+The final result will be a spritesheet, with the images displayed horizontally or vertically.
+
+It's recommended to use this Robot with
+[🤖/image/resize](/docs/robots/image-resize/) so your images are of a
+similar size before merging them.
+`),
+    format: z
+      .enum(['jpg', 'png'])
+      .default('png')
+      .describe('The output format for the modified image.'),
+    direction: z
+      .enum(['horizontal', 'vertical'])
+      .default('horizontal')
+      .describe('Specifies the direction which the images are displayed.'),
+    // TODO: default is not between 1 and 10
+    border: z
+      .number()
+      .int()
+      .default(0)
+      .describe(`
+An integer value which defines the gap between images on the spritesheet.
+
+A value of \`10\` would cause the images to have the largest gap between them, while a value of \`1\` would place the images side-by-side.
+`),
+    background: color_without_alpha.default('#FFFFFF').describe(`
+Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.php#color_names) of the color used to fill the background (only shown with a border > 1).
+
+By default, the background of transparent images is changed to white.
+
+For details about how to preserve transparency across all image types, see [this demo](/demos/image-manipulation/properly-preserve-transparency-across-all-image-types/).
+`),
+    adaptive_filtering: z
+      .boolean()
+      .default(false)
+      .describe(`
+Controls the image compression for PNG images. Setting to \`true\` results in smaller file size, while increasing processing time. It is encouraged to keep this option disabled.
+`),
+    quality: imageQualitySchema,
+  })
+  .strict()
+
+export const robotImageMergeInstructionsWithHiddenFieldsSchema =
+  robotImageMergeInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotImageMergeInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageMergeInstructions = z.infer<typeof robotImageMergeInstructionsSchema>
+export type RobotImageMergeInstructionsWithHiddenFields = z.infer<
+  typeof robotImageMergeInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageMergeInstructionsSchema = interpolateRobot(
+  robotImageMergeInstructionsSchema,
+)
+export type InterpolatableRobotImageMergeInstructions =
+  InterpolatableRobotImageMergeInstructionsInput
+
+export type InterpolatableRobotImageMergeInstructionsInput = z.input<
+  typeof interpolatableRobotImageMergeInstructionsSchema
+>
+
+export const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotImageMergeInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageMergeInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageMergeInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,112 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  aiProviderSchema,
+  granularitySchema,
+  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: {
+      recognized: {
+        robot: '/image/ocr',
+        use: ':original',
+        provider: 'gcp',
+        format: 'text',
+      },
+    },
+  },
+  example_code_description: 'Recognize text in an uploaded image and save it to a text file:',
+  extended_description: `
+> [!Warning]
+> Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses third-party AI services. The providers (AWS, GCP) will evolve their models over time, giving different responses for the same input images. Avoid relying on exact responses in your tests and application.
+`,
+  minimum_charge: 1048576,
+  output_factor: 0.6,
+  override_lvl1: 'Artificial Intelligence',
+  purpose_sentence: 'recognizes text in images and returns it in a machine-readable format',
+  purpose_verb: 'recognize',
+  purpose_word: 'recognize text',
+  purpose_words: 'Recognize text in images (OCR)',
+  service_slug: 'artificial-intelligence',
+  slot_count: 10,
+  title: 'Recognize text in images',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+  name: 'ImageOcrRobot',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  minimumChargeUsd: 0.0013,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotImageOcrInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/ocr').describe(`
+With this <dfn>Robot</dfn> you can detect and extract text from images using optical character recognition (OCR).
+
+For example, you can use the results to obtain the content of traffic signs, name tags, package labels and many more. You can also pass the text down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain phrases. For images of dense documents, results may vary and be less accurate than for small pieces of text in photos.
+`),
+    provider: aiProviderSchema.describe(`
+Which AI provider to leverage.
+
+Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+
+AWS supports detection for the following languages: English, Arabic, Russian, German, French, Italian, Portuguese and Spanish. GCP allows for a wider range of languages, with varying levels of support which can be found on the [official documentation](https://cloud.google.com/vision/docs/languages/).
+`),
+    granularity: granularitySchema.describe(`
+Whether to return a full response including coordinates for the text (\`"full"\`), or a flat list of the extracted phrases (\`"list"\`). This parameter has no effect if the \`format\` parameter is set to \`"text"\`.
+`),
+    format: z
+      .enum(['json', 'meta', 'text'])
+      .default('json')
+      .describe(`
+In what format to return the extracted text.
+- \`"json"\` returns a JSON file.
+- \`"meta"\` does not return a file, but stores the data inside Transloadit's file object (under \`\${file.meta.recognized_text}\`, which is an array of strings) that's passed around between encoding <dfn>Steps</dfn>, so that you can use the values to burn the data into videos, filter on them, etc.
+- \`"text"\` returns the recognized text as a plain UTF-8 encoded text file.
+`),
+  })
+  .strict()
+
+export const robotImageOcrInstructionsWithHiddenFieldsSchema =
+  robotImageOcrInstructionsSchema.extend({
+    result: z.union([z.literal('debug'), robotImageOcrInstructionsSchema.shape.result]).optional(),
+  })
+
+export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>
+export type RobotImageOcrInstructionsWithHiddenFields = z.infer<
+  typeof robotImageOcrInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageOcrInstructionsSchema = interpolateRobot(
+  robotImageOcrInstructionsSchema,
+)
+export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput
+
+export type InterpolatableRobotImageOcrInstructionsInput = z.input<
+  typeof interpolatableRobotImageOcrInstructionsSchema
+>
+
+export const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotImageOcrInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageOcrInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageOcrInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema
+>