transloadit 3.0.2 → 4.0.0-4

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

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 4,
+  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_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',
+}
+
+export const robotFileVerifyInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/file/verify'),
+    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.
+`),
+    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\`.
+`),
+    verify_to_be: z.string().default('pdf').describe(`
+The type that you want to match against to ensure your file is of this type. For example, \`image\` will verify whether uploaded files are images. This also works against file media types, in this case \`image/png\` would also work to match against specifically \`png\` files.
+`),
+  })
+  .strict()
+
+export type RobotFileVerifyInstructions = z.infer<typeof robotFileVerifyInstructionsSchema>

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

@@ -0,0 +1,60 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: false,
+  bytescount: 1,
+  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',
+      },
+    },
+  },
+  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',
+  purpose_verb: 'scan',
+  purpose_word: 'scan for viruses and reject malware',
+  purpose_words: 'Scan files for viruses',
+  service_slug: 'file-filtering',
+  slot_count: 38,
+  title: 'Scan files for viruses',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+}
+
+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.
+
+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.
+
+We allow the use of industry standard [EICAR files](https://www.eicar.org/download-anti-malware-testfile/) for integration testing without needing to use potentially dangerous live virus samples.
+`),
+    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.
+`),
+    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\`.
+`),
+  })
+  .strict()
+
+export type RobotFileVirusscanInstructions = z.infer<typeof robotFileVirusscanInstructionsSchema>

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

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+import { robotBase, robotUse } from './_instructions-primitives.ts'
+
+export const robotFileWatermarkInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/file/watermark'),
+    randomize: z.boolean().optional(),
+  })
+  .strict()
+
+export type RobotFileWatermarkInstructions = z.infer<typeof robotFileWatermarkInstructionsSchema>

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

@@ -0,0 +1,52 @@
+import { z } from 'zod'
+
+import { ftpBase, robotImport, path, robotBase } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  example_code: {
+    steps: {
+      imported: {
+        robot: '/ftp/import',
+        credentials: 'YOUR_FTP_CREDENTIALS',
+        path: 'path/to/files/',
+      },
+    },
+  },
+  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',
+}
+
+export const robotFtpImportInstructionsSchema = robotBase
+  .merge(robotImport)
+  .merge(ftpBase)
+  .extend({
+    robot: z.literal('/ftp/import'),
+    path: path.describe(`
+The path on your FTP server where to search for files. Files are imported recursively from all sub-directories and sub-sub-directories (and so on) from this path.
+`),
+    passive_mode: z.boolean().default(true).describe(`
+Determines if passive mode should be used for the FTP connection.
+`),
+  })
+  .strict()
+
+export type RobotFtpImportInstructions = z.infer<typeof robotFtpImportInstructionsSchema>
+export type RobotFtpImportInstructionsInput = z.input<typeof robotFtpImportInstructionsSchema>

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

@@ -0,0 +1,61 @@
+import { z } from 'zod'
+
+import { ftpBase, robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 6,
+  discount_factor: 0.15000150001500018,
+  discount_pct: 84.99984999849998,
+  docs_redirect_from: ['/docs/export-to-your-own-ftp-server/'],
+  example_code: {
+    steps: {
+      exported: {
+        robot: '/ftp/store',
+        use: ':original',
+        credentials: 'YOUR_FTP_CREDENTIALS',
+        path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+      },
+    },
+  },
+  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',
+}
+
+export const robotFtpStoreInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(ftpBase)
+  .extend({
+    robot: z.literal('/ftp/store'),
+    path: z.string().default('${unique_prefix}/${file.url_name}').describe(`
+The path at which the file is to be stored. This can contain any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables).
+
+Please note that you might need to include your homedir at the beginning of the path.
+`),
+    url_template: z.string().default('https://{HOST}/{PATH}').describe(`
+The URL of the file in the result JSON. The following [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables) are supported.
+`),
+    ssl_url_template: z.string().default('https://{HOST}/{PATH}').describe(`
+The SSL URL of the file in the result JSON. The following [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables) are supported.
+`),
+    secure: z.boolean().default(false).describe(`
+Determines whether to establish a secure connection to the FTP server using SSL.
+`),
+  })
+  .strict()
+
+export type RobotFtpStoreInstructions = z.infer<typeof robotFtpStoreInstructionsSchema>
+export type RobotFtpStoreInstructionsInput = z.input<typeof robotFtpStoreInstructionsSchema>

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

@@ -0,0 +1,77 @@
+import { z } from 'zod'
+
+import {
+  files_per_page,
+  googleBase,
+  robotImport,
+  next_page_token,
+  path,
+  recursive,
+  robotBase,
+} from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  example_code: {
+    steps: {
+      imported: {
+        robot: '/google/import',
+        credentials: 'YOUR_GOOGLE_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 Google Storage',
+  purpose_verb: 'import',
+  purpose_word: 'Google Storage',
+  purpose_words: 'Import files from Google Storage',
+  service_slug: 'file-importing',
+  slot_count: 20,
+  title: 'Import files from Google Storage',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+}
+
+export const robotGoogleImportInstructionsSchema = robotBase
+  .merge(robotImport)
+  .merge(googleBase)
+  .extend({
+    robot: z.literal('/google/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 a 404 \`GOOGLE_IMPORT_NOT_FOUND\` error.
+
+You can also use an array of path strings here to import multiple paths in the same <dfn>Robot</dfn>'s <dfn>Step</dfn>.
+`),
+    recursive: recursive.describe(`
+Setting this to \`true\` will enable importing files from subdirectories and sub-subdirectories (etc.) of the given path.
+
+Please use the pagination parameters \`start_file_name\` and \`files_per_page\` wisely here.
+`),
+    next_page_token: next_page_token.describe(`
+A string token used for pagination. The returned files of one paginated call have the next page token inside of their meta data, which needs to be used for the subsequent paging call.
+`),
+    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.
+`),
+  })
+  .strict()
+
+export type RobotGoogleImportInstructions = z.infer<typeof robotGoogleImportInstructionsSchema>
+export type RobotGoogleImportInstructionsInput = z.input<typeof robotGoogleImportInstructionsSchema>

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

@@ -0,0 +1,89 @@
+import { z } from 'zod'
+
+import { googleBase, robotBase, robotUse } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 6,
+  discount_factor: 0.15000150001500018,
+  discount_pct: 84.99984999849998,
+  example_code: {
+    steps: {
+      exported: {
+        robot: '/google/store',
+        use: ':original',
+        credentials: 'YOUR_GOOGLE_CREDENTIALS',
+        path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+      },
+    },
+  },
+  example_code_description: 'Export uploaded files to `my_target_folder` on Google Storage:',
+  has_small_icon: true,
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'File Exporting',
+  purpose_sentence: 'exports encoding results to Google Storage',
+  purpose_verb: 'export',
+  purpose_word: 'Google Storage',
+  purpose_words: 'Export files to Google Storage',
+  service_slug: 'file-exporting',
+  slot_count: 10,
+  title: 'Export files to Google Storage',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+}
+
+export const robotGoogleStoreInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(googleBase)
+  .extend({
+    robot: z.literal('/google/store').describe(`
+The URL to the exported file in your Google bucket will be presented in the Transloadit <dfn>Assembly Status</dfn> JSON. This <dfn>Robot</dfn> can also be used to export encoded files to Google's Firebase as demonstrated in [this blogpost](/blog/2018/12/2h-youtube-clone/).
+`),
+    result: z
+      .boolean()
+      .optional()
+      .describe(`Whether the results of this Step should be present in the Assembly Status JSON`),
+    credentials: z.string().describe(`
+Create a new [Google service account](https://cloud.google.com/storage/docs/authentication). Set its role to "Storage Object Creator". Choose "JSON" for the key file format and download it to your computer. You will need to upload this file when creating your <dfn>Template Credentials</dfn>.
+
+Go back to your Google credentials project and enable the "Google Cloud Storage JSON API" for it. Wait around ten minutes for the action to propagate through the Google network. Grab the project ID from the dropdown menu in the header bar on the Google site. You will also need it later on.
+
+Now you can set up the \`storage.objects.create\` and \`storage.objects.delete\` permissions. The latter is optional and only required if you intend to overwrite existing paths.
+
+To do this from the Google Cloud console, navigate to "IAM &amp; Admin" and select "Roles". From here, select "+CREATE ROLE", enter a name, set the role launch stage as general availability and set the permissions stated above.
+
+Next, relocate to your storage browser and select the ellipsis on your bucket to edit bucket permissions. From here, select "ADD MEMBER", enter your service account as a new member and select your newly created role.
+
+Then, create your associated [Template Credentials](/c/template-credentials/) in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value.
+`),
+    path: z.string().default('${unique_prefix}/${file.url_name}').describe(`
+The path at which the file is to be stored. This may include any available [Assembly Variables](/docs/topics/assembly-instructions/#assembly-variables).
+`),
+    acl: z
+      .enum([
+        'authenticated-read',
+        'bucket-owner-full-control',
+        'private',
+        'project-private',
+        'public-read',
+      ])
+      .nullable()
+      .default('public-read').describe(`
+The permissions used for this file.
+`),
+    cache_control: z.string().optional().describe(`
+The \`Cache-Control\` header determines how long browsers are allowed to cache your object for. Values specified with this parameter will be added to the object's metadata under the \`Cache-Control\` header. For more information on valid values, take a look at the [official Google documentation](https://cloud.google.com/storage/docs/metadata#cache-control).
+`),
+    url_template: z.string().default('https://{HOST}/{PATH}').describe(`
+The URL of the file in the result JSON. This may include any of the following supported [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables).
+`),
+    ssl_url_template: z.string().default('https://{HOST}/{PATH}').describe(`
+The SSL URL of the file in the result JSON. The following [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables) are supported.
+`),
+  })
+  .strict()
+
+export type RobotGoogleStoreInstructions = z.infer<typeof robotGoogleStoreInstructionsSchema>
+export type RobotGoogleStoreInstructionsInput = z.input<typeof robotGoogleStoreInstructionsSchema>

package/src/alphalib/types/robots/html-convert.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod'
+
+import { 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/taking-screenshots-of-websites/'],
+  example_code: {
+    steps: {
+      captured: {
+        robot: '/html/convert',
+        url: 'https://transloadit.com',
+      },
+    },
+  },
+  example_code_description: 'Take a full screenshot of the Transloadit homepage:',
+  extended_description: `
+**Warning:** A validation error will occur if neither an HTML file is uploaded nor a URL parameter is given. [{.alert .alert-warning}]
+
+**Note:** Any files imported within the HTML page will be included in the cost. [{.alert .alert-note}]
+`,
+  minimum_charge: 1048576,
+  output_factor: 0.5,
+  override_lvl1: 'Document Processing',
+  purpose_sentence: 'takes screenshots of web pages or uploaded HTML pages',
+  purpose_verb: 'take',
+  purpose_word: 'take screenshots of a webpage',
+  purpose_words: 'Take screenshots of webpages or HTML files',
+  service_slug: 'document-processing',
+  slot_count: 10,
+  title: 'Take screenshots of webpages or uploaded HTML files',
+  typical_file_size_mb: 0.6,
+  typical_file_type: 'webpage',
+}
+
+export const robotHtmlConvertInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/html/convert').describe(`
+A URL can be provided instead of an input HTML file, to capture a screenshot from the website referenced by the URL.
+
+Use [🤖/image/resize](/docs/transcoding/image-manipulation/image-resize/) to resize or crop the screenshot as needed.
+`),
+    url: z.string().nullable().default(null).describe(`
+The URL of the web page to be converted. Optional, as you can also upload/import HTML files and pass it to this <dfn>Robot</dfn>.
+`),
+    format: z.enum(['jpeg', 'jpg', 'pdf', 'png']).default('png').describe(`
+The format of the resulting image.
+`),
+    fullpage: z.boolean().default(true).describe(`
+Determines if a screenshot of the full page should be taken or not.
+
+If set to \`true\`, the \`height\` parameter will not have any effect, as heights of websites vary. You can control the size of the resulting image somewhat, though, by setting the \`width\` parameter.
+
+If set to \`false\`, an image will be cropped from the top of the webpage according to your \`width\` and \`height\` parameters.
+`),
+    omit_background: z.boolean().default(false).describe(`
+Determines whether to preserve a transparent background in HTML pages. Useful if you're generating artwork in HTML that you want to overlay on e.g. a video.
+
+The default of \`false\` fills transparent areas with a white background, for easier reading/printing.
+
+This parameter is only used when \`format\` is not \`pdf\`.
+`),
+    width: z.number().int().min(1).default(1024).describe(`
+The screen width that will be used, in pixels. Change this to change the  dimensions of the resulting image.
+`),
+    height: z.number().int().min(1).optional().describe(`
+The screen height that will be used, in pixels. By default this equals the length of the web page in pixels if \`fullpage\` is set to \`true\`. If \`fullpage\` is set to \`false\`, the height parameter takes effect and defaults to the value \`768\`.
+`),
+    delay: z.number().int().min(0).default(0).describe(`
+The delay (in milliseconds) applied to allow the page and all of its JavaScript to render before taking the screenshot.
+`),
+    headers: z.record(z.string()).optional().describe(`
+An object containing optional headers that will be passed along with the original request to the website. For example, this parameter can be used to pass along an authorization token along with the request.
+`),
+  })
+  .strict()
+
+export type RobotHtmlConvertInstructions = z.infer<typeof robotHtmlConvertInstructionsSchema>

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

@@ -0,0 +1,79 @@
+import { z } from 'zod'
+
+import { robotImport, robotBase } from './_instructions-primitives.ts'
+import type { RobotMeta } from './_instructions-primitives.ts'
+
+export const meta: RobotMeta = {
+  allowed_for_url_transform: true,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  docs_redirect_from: ['/docs/import-files-over-http/'],
+  example_code: {
+    steps: {
+      imported: {
+        robot: '/http/import',
+        url: 'https://demos.transloadit.com/inputs/chameleon.jpg',
+      },
+    },
+  },
+  example_code_description: 'Import an image from a specific URL:',
+  minimum_charge: 0,
+  output_factor: 1,
+  override_lvl1: 'File Importing',
+  purpose_sentence: 'imports any file that is publicly available via a web URL into Transloadit',
+  purpose_verb: 'import',
+  purpose_word: 'Webservers',
+  purpose_words: 'Import files from web servers',
+  service_slug: 'file-importing',
+  slot_count: 10,
+  title: 'Import files from web servers',
+  typical_file_size_mb: 1.2,
+  typical_file_type: 'file',
+}
+
+export const robotHttpImportInstructionsSchema = robotBase
+  .merge(robotImport)
+  .extend({
+    robot: z.literal('/http/import').describe(`
+The result of this <dfn>Robot</dfn> will carry a field \`import_url\` in their metadata, which references the URL from which they were imported. Further conversion results that use this file will also carry this \`import_url\` field. This allows you to to match conversion results with the original import URL that you used.
+
+This <dfn>Robot</dfn> knows to interpret links to files on these services:
+
+- Dropbox
+- Google Drive
+- Google Docs
+- OneDrive
+
+Instead of downloading the HTML page previewing the file, the actual file itself will be imported.
+`),
+    url: z.union([z.string().url(), z.array(z.string().url())]).describe(`
+The URL from which the file to be imported can be retrieved.
+
+You can also specify an array of URLs or a string of \`|\` delimited URLs to import several files at once. Please also check the \`url_delimiter\` parameter for that.
+`),
+    url_delimiter: z.string().default('|').describe(`
+Provides the delimiter that is used to split the URLs in your \`url\` parameter value.
+`),
+    headers: z.array(z.string()).default([]).describe(`
+Custom headers to be sent for file import.
+
+This is an empty array by default, such that no additional headers except the necessary ones (e.g. Host) are sent.
+`),
+    force_name: z
+      .union([z.string(), z.array(z.string())])
+      .nullable()
+      .default(null).describe(`
+Custom name for the imported file(s). Defaults to \`null\`, which means the file names are derived from the supplied URL(s).
+`),
+    import_on_errors: z.array(z.string()).default([]).describe(`
+Setting this to \`"meta"\` will still import the file on metadata extraction errors. \`ignore_errors\` is similar, it also ignores the error and makes sure the Robot doesn't stop, but it doesn't import the file.
+`),
+    fail_fast: z.boolean().default(false).describe(`
+Disable the internal retry mechanism, and fail immediately if a resource can't be imported. This can be useful for performance critical applications.
+`),
+  })
+  .strict()
+
+export type RobotHttpImportInstructions = z.infer<typeof robotHttpImportInstructionsSchema>
+export type RobotHttpImportInstructionsInput = z.input<typeof robotHttpImportInstructionsSchema>

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

@@ -0,0 +1,74 @@
+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: {
+      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. [{.alert .alert-warning}]
+`,
+  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',
+}
+
+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.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 type RobotImageDescribeInstructions = z.infer<typeof robotImageDescribeInstructionsSchema>