transloadit 4.14.0 → 5.0.0

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

@@ -1,55 +1,35 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  files_per_page,
+  createStorageImportExample,
+  defineRobot,
   googleBase,
-  interpolateRobot,
   next_page_token,
   path,
   recursive,
+  recursiveImportPageSize,
   robotBase,
   robotImport,
+  robotImportMeta,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  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,
-      },
-    },
-  },
+  ...robotImportMeta,
+  example_code: createStorageImportExample('/google/import', 'YOUR_GOOGLE_CREDENTIALS'),
   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',
+  purpose_sentence: 'imports whole directories of files from Google Cloud Storage',
+  purpose_word: 'Google Cloud Storage',
+  purpose_words: 'Import files from Google Cloud Storage',
+  title: 'Import files from Google Cloud Storage',
   name: 'GoogleImportRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 20,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-  stage: 'ga',
 }
 
 export const robotGoogleImportInstructionsSchema = robotBase
@@ -76,40 +56,26 @@ Please use the pagination parameters \`start_file_name\` and \`files_per_page\`
     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.
-`),
+    files_per_page: recursiveImportPageSize,
   })
   .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 robotDefinition: RobotDefinition<typeof robotGoogleImportInstructionsSchema.shape> =
+  defineRobot(meta, robotGoogleImportInstructionsSchema)
 
-export const interpolatableRobotGoogleImportInstructionsSchema = interpolateRobot(
-  robotGoogleImportInstructionsSchema,
-)
-export type InterpolatableRobotGoogleImportInstructions =
-  InterpolatableRobotGoogleImportInstructionsInput
+export const {
+  withHiddenFields: robotGoogleImportInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotGoogleImportInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotGoogleImportInstructionsInput = z.input<
-  typeof interpolatableRobotGoogleImportInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotGoogleImportInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotGoogleImportInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotGoogleImportInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema
->
+export type RobotGoogleImportInstructions = Instructions['output']
+export type RobotGoogleImportInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotGoogleImportInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotGoogleImportInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,45 +1,31 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { googleBase, interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+import {
+  createStorageStoreExample,
+  defineRobot,
+  googleBase,
+  robotBase,
+  robotStoreMeta,
+  robotUse,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  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:',
+  ...robotStoreMeta,
+  example_code: createStorageStoreExample('/google/store', 'YOUR_GOOGLE_CREDENTIALS'),
+  example_code_description:
+    'Export uploaded files to `my_target_folder` in a Google Cloud Storage bucket:',
   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',
+  purpose_sentence: 'exports encoding results to Google Cloud Storage',
+  purpose_word: 'Google Cloud Storage',
+  purpose_words: 'Export files to Google Cloud Storage',
+  title: 'Export files to Google Cloud Storage',
   name: 'GoogleStoreRobot',
-  priceFactor: 6.6666,
-  queueSlotCount: 10,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: false,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotGoogleStoreInstructionsSchema = robotBase
@@ -106,34 +92,22 @@ The SSL URL of the file in the result JSON. The following [Assembly variables](/
   })
   .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 robotDefinition: RobotDefinition<typeof robotGoogleStoreInstructionsSchema.shape> =
+  defineRobot(meta, robotGoogleStoreInstructionsSchema)
 
-export const interpolatableRobotGoogleStoreInstructionsSchema = interpolateRobot(
-  robotGoogleStoreInstructionsSchema,
-)
-export type InterpolatableRobotGoogleStoreInstructions =
-  InterpolatableRobotGoogleStoreInstructionsInput
+export const {
+  withHiddenFields: robotGoogleStoreInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotGoogleStoreInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotGoogleStoreInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotGoogleStoreInstructionsInput = z.input<
-  typeof interpolatableRobotGoogleStoreInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotGoogleStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotGoogleStoreInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotGoogleStoreInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotGoogleStoreInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotGoogleStoreInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotGoogleStoreInstructionsWithHiddenFieldsSchema
->
+export type RobotGoogleStoreInstructions = Instructions['output']
+export type RobotGoogleStoreInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotGoogleStoreInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotGoogleStoreInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotGoogleStoreInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotGoogleStoreInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,13 +1,20 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+import {
+  defineRobotWithHiddenFields,
+  robotBase,
+  robotDocumentProcessingMeta,
+  robotUse,
+} from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
+  ...robotDocumentProcessingMeta,
   example_code: {
     steps: {
       captured: {
@@ -24,27 +31,16 @@ export const meta: RobotMetaInput = {
 > [!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
@@ -129,37 +125,30 @@ See [Playwright's documentation](https://playwright.dev/docs/api/class-page#page
   })
   .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(),
-  })
+const hiddenFields = {
+  debuginfo: z.boolean().optional(),
+  timeouts: z.record(z.unknown()).optional(),
+  actions: z.array(z.record(z.unknown())).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
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotHtmlConvertInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotHtmlConvertInstructionsSchema, hiddenFields)
+
+export const {
+  withHiddenFields: robotHtmlConvertInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotHtmlConvertInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
+
+export type RobotHtmlConvertInstructions = Instructions['output']
+export type RobotHtmlConvertInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotHtmlConvertInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotHtmlConvertInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotHtmlConvertInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotHtmlConvertInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,19 +1,21 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
+import { httpImportRobotErrors } from '../responseErrors/HttpImportRobot.ts'
 import {
+  httpHeaderSafetyDescription,
+  httpUrlSchema,
   interpolateRobot,
   return_file_stubs,
   robotBase,
   robotImport,
+  robotImportMeta,
   robotUseWithHiddenFields,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 10,
-  discount_factor: 0.1,
-  discount_pct: 90,
+  ...robotImportMeta,
   example_code: {
     steps: {
       imported: {
@@ -23,33 +25,20 @@ export const meta: RobotMetaInput = {
     },
   },
   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.
+The result of this <dfn>Robot</dfn> will carry a field \`import_url\` in its metadata, which references the URL from which it was imported. Further conversion results that use this file will also carry this \`import_url\` field. This allows you 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:
 
@@ -60,9 +49,11 @@ This <dfn>Robot</dfn> knows to interpret links to files on these services:
 
 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(`
+    url: z.union([httpUrlSchema, z.array(httpUrlSchema)]).describe(`
 The URL from which the file to be imported can be retrieved.
 
+HTTPS URLs must present a valid certificate trusted by Transloadit and matching the requested hostname. Self-signed, expired, or hostname-mismatched certificates cause \`${httpImportRobotErrors.HTTP_IMPORT_FAILURE.error}\`.
+
 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
@@ -88,6 +79,8 @@ Headers can be specified as:
 - An array of objects with header names as keys and values as values
 - A JSON string that will be parsed into an object
 
+${httpHeaderSafetyDescription}
+
 The same \`headers\` value is sent with every URL in this \`/http/import\` Step. If \`url\` is an
 array, \`headers\` is not matched to the URLs by array index. Use separate \`/http/import\` Steps
 when different URLs need different headers.
@@ -174,3 +167,12 @@ export type InterpolatableRobotHttpImportInstructionsWithHiddenFields = z.infer<
 export type InterpolatableRobotHttpImportInstructionsWithHiddenFieldsInput = z.input<
   typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema
 >
+
+export const robotDefinition: RobotSchemaPair<
+  typeof interpolatableRobotHttpImportInstructionsSchema,
+  typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema
+> = {
+  meta,
+  interpolatable: interpolatableRobotHttpImportInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema,
+}

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

@@ -0,0 +1,196 @@
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
+
+import { z } from 'zod'
+
+import {
+  defineRobot,
+  httpHeaderSafetyDescription,
+  httpUrlSchema,
+  robotBase,
+  robotCodeEvaluationMeta,
+  robotUse,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  ...robotCodeEvaluationMeta,
+  example_code: {
+    steps: {
+      request: {
+        robot: '/http/request',
+        method: 'POST',
+        payload: 'metadata',
+        url: 'https://example.com/transloadit/files',
+        use: [],
+      },
+    },
+  },
+  example_code_description: 'Ask your application which input files should continue:',
+  extended_description: `
+Use this <dfn>Robot</dfn> when your application should inspect the current Assembly state or input
+files during an Assembly and return which input files should continue to later, statically declared
+Steps, or return new result-file URLs that Transloadit should download and emit from this Step.
+
+Request format:
+
+- \`payload: "none"\` sends no request body.
+- \`payload: "metadata"\` sends \`application/json\` with \`assembly\`, \`fields\`,
+  \`previous_step\`, \`file\`, and \`files\`.
+- \`payload: "file"\` sends \`multipart/form-data\` with a \`payload\` JSON field and the first input
+  file as form part \`file\`.
+- \`payload: "files"\` sends \`multipart/form-data\` with a \`payload\` JSON field and all input files
+  as repeated form parts named \`files[]\`.
+
+Your endpoint must respond with a 2xx status. It can return an empty body, \`[]\`, a single file
+object, an array of file objects, or an object with \`files\` as an array or object map. Returned
+files must include either:
+
+- \`path\`: Selects an input file path that was sent in the request payload.
+- \`url\`: Downloads a new HTTP(S) result file and emits it from this Step.
+
+The response never changes the Assembly flow. To process returned files, declare the following Steps
+in the Assembly Template and use this Step as their input.
+`,
+  override_lvl1: 'Workflow Automation',
+  purpose_sentence:
+    'calls your application during an Assembly and emits returned input file references',
+  purpose_verb: 'run',
+  purpose_word: 'HTTP endpoint',
+  purpose_words: 'Call HTTP endpoints',
+  title: 'Call HTTP endpoints during Assemblies',
+  name: 'HttpRequestRobot',
+  queueSlotCount: 1,
+  stage: 'alpha',
+}
+
+const headerValue = z.union([z.boolean(), z.number(), z.string(), z.null()])
+export const robotHttpRequestInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/http/request').describe(`
+Calls an HTTP endpoint during the Assembly and expects optional JSON describing zero or more input
+files or result-file URLs to emit from this Step.
+
+Your endpoint must return a 2xx response. An empty body, \`[]\`, or \`{ "files": [] }\` means this
+Step emits no files. You can also return one file object, an array of file objects, or
+\`{ "files": [...] }\` / \`{ "files": { "name": {...} } }\`. Returned file objects must include
+either a \`path\` that matches one of the input file paths sent to your endpoint, or an HTTP(S)
+\`url\` that Transloadit downloads and emits as a new result file.
+`),
+    url: httpUrlSchema.describe(`
+The HTTP or HTTPS endpoint to call.
+`),
+    method: z
+      .enum(['DELETE', 'GET', 'PATCH', 'POST', 'PUT'])
+      .default('POST')
+      .describe(`
+HTTP method to use for the request.
+`),
+    payload: z
+      .enum(['none', 'metadata', 'file', 'files'])
+      .default('none')
+      .describe(`
+Controls what is sent to your endpoint.
+
+- \`none\`: Send no request body.
+- \`metadata\`: Send a JSON body with Assembly metadata, fields, the previous Step, and file metadata.
+- \`file\`: Send multipart form data with a \`payload\` JSON field and the first input file as a
+  \`file\` part.
+- \`files\`: Send multipart form data with a \`payload\` JSON field and all input files as repeated
+  \`files[]\` parts. Useful with \`bundle_steps\`.
+
+The \`payload\` JSON object contains \`assembly\`, \`fields\`, \`previous_step\`, \`file\`, and
+\`files\`. \`file\` is the first input file’s metadata or \`null\`; \`files\` is an array of input
+file metadata.
+`),
+    headers: z
+      .union([
+        z.array(z.string()),
+        z.array(z.record(headerValue)),
+        z.record(headerValue),
+        z.string(),
+      ])
+      .default([])
+      .describe(`
+Custom request headers.
+
+Headers can be specified as an array of strings in the format \`"Header-Name: value"\`, an array
+of objects, an object map, or a JSON string that will be parsed into an object/array.
+
+${httpHeaderSafetyDescription}
+`),
+    timeout: z
+      .number()
+      .int()
+      .positive()
+      .max(300)
+      .default(60)
+      .describe(`
+Maximum number of seconds to wait for the HTTP request.
+
+The effective timeout is the lower of this value and Transloadit’s server-side cap. The cap is 30
+seconds plus 1 second per MiB sent to your endpoint.
+`),
+    max_response_size: z
+      .number()
+      .int()
+      .positive()
+      .max(10 * 1024 * 1024)
+      .default(1024 * 1024)
+      .describe(`
+Maximum accepted response size in bytes. The response should normally be a small JSON document.
+`),
+    max_result_files: z
+      .number()
+      .int()
+      .positive()
+      .max(100)
+      .default(10)
+      .describe(`
+Maximum number of files that the endpoint may return.
+`),
+    max_result_file_size: z
+      .number()
+      .int()
+      .positive()
+      .max(5 * 1024 * 1024 * 1024)
+      .default(100 * 1024 * 1024)
+      .describe(`
+Maximum allowed size in bytes for each result file returned by URL. If the remote server reports a
+larger file size, the result download is rejected before it starts. If the remote server does not
+report a size upfront, the download is aborted once this limit is exceeded.
+`),
+    result_download_timeout: z
+      .number()
+      .int()
+      .positive()
+      .max(600)
+      .default(120)
+      .describe(`
+Maximum number of seconds to spend downloading each result file returned by URL.
+`),
+  })
+  .strict()
+
+export const robotDefinition: RobotDefinition<typeof robotHttpRequestInstructionsSchema.shape> =
+  defineRobot(meta, robotHttpRequestInstructionsSchema)
+
+export const {
+  withHiddenFields: robotHttpRequestInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotHttpRequestInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotHttpRequestInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
+
+export type RobotHttpRequestInstructions = Instructions['output']
+export type RobotHttpRequestInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotHttpRequestInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotHttpRequestInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotHttpRequestInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotHttpRequestInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']