@transloadit/node 4.1.3

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

@@ -0,0 +1,115 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  files_per_page,
+  googleBase,
+  interpolateRobot,
+  next_page_token,
+  path,
+  recursive,
+  robotBase,
+  robotImport,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  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',
+  name: 'GoogleImportRobot',
+  priceFactor: 6.6666,
+  queueSlotCount: 20,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: false,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+  stage: 'ga',
+}
+
+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 const robotGoogleImportInstructionsWithHiddenFieldsSchema =
+  robotGoogleImportInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotGoogleImportInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotGoogleImportInstructions = z.infer<typeof robotGoogleImportInstructionsSchema>
+export type RobotGoogleImportInstructionsWithHiddenFields = z.infer<
+  typeof robotGoogleImportInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotGoogleImportInstructionsSchema = interpolateRobot(
+  robotGoogleImportInstructionsSchema,
+)
+export type InterpolatableRobotGoogleImportInstructions =
+  InterpolatableRobotGoogleImportInstructionsInput
+
+export type InterpolatableRobotGoogleImportInstructionsInput = z.input<
+  typeof interpolatableRobotGoogleImportInstructionsSchema
+>
+
+export const interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotGoogleImportInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,139 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import { googleBase, interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  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',
+  name: 'GoogleStoreRobot',
+  priceFactor: 6.6666,
+  queueSlotCount: 10,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: false,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+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, click "Create Role", enter a name, set the role launch stage to _General availability,_ and set the permissions stated above.
+
+Next, go to 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 const robotGoogleStoreInstructionsWithHiddenFieldsSchema =
+  robotGoogleStoreInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotGoogleStoreInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotGoogleStoreInstructions = z.infer<typeof robotGoogleStoreInstructionsSchema>
+export type RobotGoogleStoreInstructionsWithHiddenFields = z.infer<
+  typeof robotGoogleStoreInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotGoogleStoreInstructionsSchema = interpolateRobot(
+  robotGoogleStoreInstructionsSchema,
+)
+export type InterpolatableRobotGoogleStoreInstructions =
+  InterpolatableRobotGoogleStoreInstructionsInput
+
+export type InterpolatableRobotGoogleStoreInstructionsInput = z.input<
+  typeof interpolatableRobotGoogleStoreInstructionsSchema
+>
+
+export const interpolatableRobotGoogleStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotGoogleStoreInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotGoogleStoreInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotGoogleStoreInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotGoogleStoreInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotGoogleStoreInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,165 @@
+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,
+  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.
+
+> [!Note]
+> Any files imported within the HTML page will be included in the cost.
+`,
+  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',
+  name: 'HtmlConvertRobot',
+  priceFactor: 1,
+  queueSlotCount: 30,
+  minimumCharge: 1048576,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+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/robots/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.
+`),
+    wait_until: z
+      .enum(['domcontentloaded', 'load', 'networkidle', 'commit'])
+      .default('networkidle')
+      .describe(`
+The event to wait for before taking the screenshot. Used for loading Javascript, and images.
+
+See [Playwright's documentation](https://playwright.dev/docs/api/class-page#page-wait-for-load-state) for more information.
+`),
+  })
+  .strict()
+
+export const robotHtmlConvertInstructionsWithHiddenFieldsSchema =
+  robotHtmlConvertInstructionsSchema.extend({
+    debuginfo: z.boolean().optional(),
+    timeouts: z.record(z.unknown()).optional(),
+    actions: z.array(z.record(z.unknown())).optional(),
+    result: z
+      .union([z.literal('debug'), robotHtmlConvertInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotHtmlConvertInstructions = z.infer<typeof robotHtmlConvertInstructionsSchema>
+export type RobotHtmlConvertInstructionsWithHiddenFields = z.infer<
+  typeof robotHtmlConvertInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotHtmlConvertInstructionsSchema = interpolateRobot(
+  robotHtmlConvertInstructionsSchema,
+)
+export type InterpolatableRobotHtmlConvertInstructions =
+  InterpolatableRobotHtmlConvertInstructionsInput
+
+export type InterpolatableRobotHtmlConvertInstructionsInput = z.input<
+  typeof interpolatableRobotHtmlConvertInstructionsSchema
+>
+
+export const interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotHtmlConvertInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotHtmlConvertInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotHtmlConvertInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,168 @@
+import { z } from 'zod'
+
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  interpolateRobot,
+  return_file_stubs,
+  robotBase,
+  robotImport,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: true,
+  bytescount: 10,
+  discount_factor: 0.1,
+  discount_pct: 90,
+  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',
+  name: 'HttpImportRobot',
+  priceFactor: 10,
+  queueSlotCount: 10,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: false,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+  stage: 'ga',
+}
+
+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
+      .union([
+        z.array(z.string()),
+        z.array(z.record(z.string())),
+        z.string(), // For JSON strings like '{"X-Database":"volt"}'
+      ])
+      .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.
+
+Headers can be specified as:
+- An array of strings in the format "Header-Name: value"
+- An array of objects with header names as keys and values as values
+- A JSON string that will be parsed into an object
+`),
+    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.
+`),
+    return_file_stubs,
+    range: z
+      .union([z.string(), z.array(z.string())])
+      .optional()
+      .describe(`
+Allows you to specify one or more byte ranges to import from the file. The server must support range requests for this to work.
+
+**Single range**: Use a string like \`"0-99"\` to import bytes 0-99 (the first 100 bytes).
+
+**Multiple ranges**: Use an array like \`["0-99", "200-299"]\` to import multiple separate ranges. The resulting file will contain all requested ranges concatenated together, with zero bytes (\\0) filling any gaps between non-contiguous ranges.
+
+**Range formats**:
+- \`"0-99"\`: Bytes 0 through 99 (inclusive)
+- \`"100-199"\`: Bytes 100 through 199 (inclusive)
+- \`"-100"\`: The last 100 bytes of the file
+
+**Important notes**:
+- The server must support HTTP range requests (respond with 206 Partial Content)
+- If the server doesn't support range requests, the entire file will be imported instead
+- Overlapping ranges are allowed and will be included as requested
+- The resulting file size will be the highest byte position requested, with gaps filled with zero bytes
+`),
+  })
+  .strict()
+
+export const robotHttpImportInstructionsWithHiddenFieldsSchema =
+  robotHttpImportInstructionsSchema.extend({
+    force_original_id: z.string().optional(),
+    force_name: z
+      .union([z.string(), z.record(z.string())])
+      .optional()
+      .describe(`
+Force a specific filename for imported files. Can be a string to apply to all imports, or an object mapping URLs to filenames.
+`),
+    result: z
+      .union([z.literal('debug'), robotHttpImportInstructionsSchema.shape.result])
+      .optional(),
+    credentials: z.string().optional(), // For test purposes
+    bucket: z.string().optional(), // For test purposes
+    // Override url to support relative URLs in tests with bucket
+    url: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+
+export type RobotHttpImportInstructions = z.infer<typeof robotHttpImportInstructionsSchema>
+export type RobotHttpImportInstructionsWithHiddenFields = z.infer<
+  typeof robotHttpImportInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotHttpImportInstructionsSchema = interpolateRobot(
+  robotHttpImportInstructionsSchema,
+)
+export type InterpolatableRobotHttpImportInstructions =
+  InterpolatableRobotHttpImportInstructionsInput
+
+export type InterpolatableRobotHttpImportInstructionsInput = z.input<
+  typeof interpolatableRobotHttpImportInstructionsSchema
+>
+
+export const interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotHttpImportInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotHttpImportInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotHttpImportInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema
+>

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

@@ -0,0 +1,95 @@
+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,
+  discount_factor: 1,
+  bytescount: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      remove_background: {
+        robot: '/image/bgremove',
+        use: ':original',
+      },
+    },
+  },
+  example_code_description: 'Remove the background from the uploaded image:',
+  minimum_charge: 0,
+  output_factor: 0.6,
+  override_lvl1: 'Image Manipulation',
+  purpose_sentence: 'removes the background from images',
+  purpose_verb: 'remove',
+  purpose_word: 'remove',
+  purpose_words: 'Remove the background from images',
+  service_slug: 'image-manipulation',
+  slot_count: 10,
+  title: 'Remove the background from images',
+  typical_file_size_mb: 0.8,
+  typical_file_type: 'image',
+  name: 'ImageBgremoveRobot',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  minimumChargeUsd: 0.006,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotImageBgremoveInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/image/bgremove'),
+    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.'),
+    model: z
+      .string()
+      .optional()
+      .describe(
+        'Provider-specific model to use for removing the background. Mostly intended for testing and evaluation.',
+      ),
+  })
+  .strict()
+
+export const robotImageBgremoveInstructionsWithHiddenFieldsSchema =
+  robotImageBgremoveInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotImageBgremoveInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotImageBgremoveInstructions = z.infer<typeof robotImageBgremoveInstructionsSchema>
+export type RobotImageBgremoveInstructionsWithHiddenFields = z.infer<
+  typeof robotImageBgremoveInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotImageBgremoveInstructionsSchema = interpolateRobot(
+  robotImageBgremoveInstructionsSchema,
+)
+export type InterpolatableRobotImageBgremoveInstructions =
+  InterpolatableRobotImageBgremoveInstructionsInput
+
+export type InterpolatableRobotImageBgremoveInstructionsInput = z.input<
+  typeof interpolatableRobotImageBgremoveInstructionsSchema
+>
+
+export const interpolatableRobotImageBgremoveInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotImageBgremoveInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotImageBgremoveInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotImageBgremoveInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotImageBgremoveInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotImageBgremoveInstructionsWithHiddenFieldsSchema
+>