transloadit 3.0.2 → 4.0.0-2

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

@@ -0,0 +1,131 @@
+import { z } from 'zod'
+
+import { aiProviderSchema, robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  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',
+  redirect_from: ['/services/computer-vision/image-facedetect/'],
+  service_slug: 'artificial-intelligence',
+  slot_count: 20,
+  title: 'Detect faces in images',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+}
+
+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/transcoding/image-manipulation/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 type RobotImageFacedetectInstructions = z.infer<
+  typeof robotImageFacedetectInstructionsSchema
+>

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

@@ -0,0 +1,32 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse } from './_instructions-primitives.ts'
+
+export const robotImageGenerateInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/generate'),
+    model: z.string(),
+    prompt: z.string().describe('The prompt describing the desired image content.'),
+    format: z
+      .enum(['jpeg', 'png', 'gif', 'webp', 'svg'])
+      .optional()
+      .describe('Format of the generated image.'),
+    seed: z.number().optional().describe('Seed for the random number generator.'),
+    aspectRatio: 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.'),
+  })
+  .strict()
+
+export const robotImageGenerateInstructionsWithHiddenFieldsSchema =
+  robotImageGenerateInstructionsSchema.extend({
+    result: z.union([z.literal('debug'), robotImageGenerateInstructionsSchema.shape.result]),
+    provider: z.string().optional().describe('Provider for generating the image.'),
+  })
+
+export type RobotImageGenerateInstructions = z.infer<typeof robotImageGenerateInstructionsSchema>
+export type RobotImageGenerateInstructionsWithHiddenFields = z.infer<
+  typeof robotImageGenerateInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,81 @@
+import { z } from 'zod'
+
+import {
+  color_without_alpha,
+  imageQualitySchema,
+  robotBase,
+  robotUse,
+} from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  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',
+}
+
+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/transcoding/image-manipulation/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().min(1).max(10).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 type RobotImageMergeInstructions = z.infer<typeof robotImageMergeInstructionsSchema>

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

@@ -0,0 +1,71 @@
+import { z } from 'zod'
+
+import {
+  aiProviderSchema,
+  granularitySchema,
+  robotBase,
+  robotUse,
+} from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  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. [{.alert .alert-warning}]
+`,
+  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',
+}
+
+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 type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>

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

@@ -0,0 +1,61 @@
+import { z } from 'zod'
+
+import { optimize_priority, robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  docs_redirect_from: ['/docs/image-optimization/'],
+  example_code: {
+    steps: {
+      optimized: {
+        robot: '/image/optimize',
+        use: ':original',
+      },
+    },
+  },
+  example_code_description: 'Optimize uploaded images:',
+  minimum_charge: 0,
+  output_factor: 0.6,
+  override_lvl1: 'Image Manipulation',
+  purpose_sentence: 'reduces the size of images while maintaining the same visual quality',
+  purpose_verb: 'optimize',
+  purpose_word: 'optimize',
+  purpose_words: 'Optimize images without quality loss',
+  service_slug: 'image-manipulation',
+  slot_count: 15,
+  title: 'Optimize images without quality loss',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+}
+
+export const robotImageOptimizeInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/optimize').describe(`
+With this <dfn>Robot</dfn> it's possible to reduce the file size of your JPEG, PNG, GIF, WEBP and SVG images by up to 80% for big images and 65% for small to medium sized ones — while keeping their original quality!
+
+This <dfn>Robot</dfn> enables you to lower your storage and bandwidth costs, and improves your user experience and monetization by reducing the load time of image-intensive web pages.
+
+It works well together with [🤖/image/resize](/docs/transcoding/image-manipulation/image-resize/) to bring the full power of resized and optimized images to your website or app.
+
+**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/transcoding/file-filtering/file-filter/) workflows for this. [{.alert .alert-note}]
+`),
+    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%.
+`),
+    progressive: z.boolean().default(false).describe(`
+Interlaces the image if set to \`true\`, which makes the result image load progressively in browsers. Instead of rendering the image from top to bottom, the browser will first show a low-res blurry version of the image which is then quickly replaced with the actual image as the data arrives. This greatly increases the user experience, but comes at a loss of about 10% of the file size reduction.
+`),
+    preserve_meta_data: z.boolean().default(true).describe(`
+Specifies if the image's metadata should be preserved during the optimization, or not. If it is not preserved, the file size is even further reduced. But be aware that this could strip a photographer's copyright information, which for obvious reasons can be frowned upon.
+`),
+    fix_breaking_images: z.boolean().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.
+`),
+  })
+  .strict()
+export type RobotImageOptimizeInstructions = z.infer<typeof robotImageOptimizeInstructionsSchema>

package/src/alphalib/types/robots/image-remove-background.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse } from './_instructions-primitives.ts'
+
+export const robotImageRemoveBackgroundInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/remove-background'),
+    select: z
+      .enum(['foreground', 'background'])
+      .optional()
+      .describe('Region to select and keep in the image. The other region is removed.'),
+    format: z.enum(['png', 'gif', 'webp']).optional().describe('Format of the generated image.'),
+    provider: z
+      .enum(['transloadit', 'replicate', 'fal'])
+      .optional()
+      .describe('Provider to use for removing the background.'),
+  })
+  .strict()
+
+export type RobotImageRemoveBackgroundInstructions = z.infer<
+  typeof robotImageRemoveBackgroundInstructionsSchema
+>