@transloadit/zod 4.5.0 → 5.0.0

package/dist/v4/robots/html-convert.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotHtmlConvertInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -54,15 +55,22 @@ export declare const robotHtmlConvertInstructionsSchema: z.ZodObject<{
         commit: "commit";
     }>>;
 }, z.core.$strict>;
+declare const hiddenFields: {
+    debuginfo: z.ZodOptional<z.ZodBoolean>;
+    timeouts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotHtmlConvertInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotHtmlConvertInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -105,28 +113,26 @@ export declare const robotHtmlConvertInstructionsWithHiddenFieldsSchema: z.ZodOb
         networkidle: "networkidle";
         commit: "commit";
     }>>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
     debuginfo: z.ZodOptional<z.ZodBoolean>;
     timeouts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     actions: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotHtmlConvertInstructions = z.infer<typeof robotHtmlConvertInstructionsSchema>;
-export type RobotHtmlConvertInstructionsWithHiddenFields = z.infer<typeof robotHtmlConvertInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotHtmlConvertInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotHtmlConvertInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -145,42 +151,40 @@ export declare const interpolatableRobotHtmlConvertInstructionsSchema: z.ZodObje
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/html/convert">;
-    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    url: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         pdf: "pdf";
         jpeg: "jpeg";
         jpg: "jpg";
         png: "png";
     }>]>>;
-    fullpage: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    omit_background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    width: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    fullpage: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    omit_background: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    width: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    delay: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    delay: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    wait_until: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    wait_until: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         domcontentloaded: "domcontentloaded";
         load: "load";
         networkidle: "networkidle";
         commit: "commit";
     }>]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotHtmlConvertInstructions = InterpolatableRobotHtmlConvertInstructionsInput;
-export type InterpolatableRobotHtmlConvertInstructionsInput = z.input<typeof interpolatableRobotHtmlConvertInstructionsSchema>;
-export declare const interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -199,30 +203,36 @@ export declare const interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsS
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/html/convert">;
-    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    url: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         pdf: "pdf";
         jpeg: "jpeg";
         jpg: "jpg";
         png: "png";
     }>]>>;
-    fullpage: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    omit_background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    width: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    fullpage: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    omit_background: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    width: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    delay: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    delay: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    wait_until: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    wait_until: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         domcontentloaded: "domcontentloaded";
         load: "load";
         networkidle: "networkidle";
         commit: "commit";
     }>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
     debuginfo: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     timeouts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     actions: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotHtmlConvertInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotHtmlConvertInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema>;
+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'];
+export {};
 //# sourceMappingURL=html-convert.d.ts.map

package/dist/v4/robots/html-convert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"html-convert.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/html-convert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAyClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+EpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQ3D,CAAA;AAEJ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5D,CAAA;AACD,MAAM,MAAM,0CAA0C,GACpD,+CAA+C,CAAA;AAEjD,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,gDAAgD,CACxD,CAAA;AAED,eAAO,MAAM,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5E,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,gEAAgE,CACxE,CAAA;AACD,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,gEAAgE,CACxE,CAAA"}
+{"version":3,"file":"html-convert.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/html-convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cA4BlB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6EpC,CAAA;AAEX,QAAA,MAAM,YAAY;;;;CAIjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,kCAAkC,CAAC,KAAK,EAC/C,OAAO,YAAY,CACkE,CAAA;AAEvF,eAAO,MACa,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACpD,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAChC,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC/E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,4BAA4B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACjE,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACvF,MAAM,MAAM,0CAA0C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC5F,MAAM,MAAM,+CAA+C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACjG,MAAM,MAAM,0DAA0D,GACpE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,+DAA+D,GACzE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v4/robots/html-convert.js

@@ -1,9 +1,8 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { defineRobotWithHiddenFields, robotBase, robotDocumentProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
+    ...robotDocumentProcessingMeta,
     example_code: {
         steps: {
             captured: {
@@ -20,27 +19,16 @@ export const meta = {
 > [!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)
@@ -91,11 +79,10 @@ This parameter is only used when \`format\` is not \`pdf\`.
         .describe(`
 The screen width that will be used, in pixels. Change this to change the  dimensions of the resulting image.
 `),
-    height: z
+    height: optionalWithV3Semantics(z
         .number()
         .int()
-        .min(1)
-        .optional()
+        .min(1))
         .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\`.
 `),
@@ -107,8 +94,7 @@ The screen height that will be used, in pixels. By default this equals the lengt
         .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(), z.string())
-        .optional()
+    headers: optionalWithV3Semantics(z.record(z.string(), z.string()))
         .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.
 `),
@@ -122,13 +108,10 @@ 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.string(), z.unknown()).optional(),
-    actions: z.array(z.record(z.string(), z.unknown())).optional(),
-    result: z
-        .union([z.literal('debug'), robotHtmlConvertInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotHtmlConvertInstructionsSchema = interpolateRobot(robotHtmlConvertInstructionsSchema);
-export const interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema = interpolateRobot(robotHtmlConvertInstructionsWithHiddenFieldsSchema);
+const hiddenFields = {
+    debuginfo: optionalWithV3Semantics(z.boolean()),
+    timeouts: optionalWithV3Semantics(z.record(z.string(), z.unknown())),
+    actions: optionalWithV3Semantics(z.array(z.record(z.string(), z.unknown()))),
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotHtmlConvertInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotHtmlConvertInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotHtmlConvertInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotHtmlConvertInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/http-import.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotHttpImportInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -35,13 +36,14 @@ export declare const robotHttpImportInstructionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const robotHttpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -88,65 +90,67 @@ export type RobotHttpImportInstructions = z.infer<typeof robotHttpImportInstruct
 export type RobotHttpImportInstructionsWithHiddenFields = z.infer<typeof robotHttpImportInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotHttpImportInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    force_name: z.ZodPrefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         import: "import";
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
-    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    import_on_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
     }>]>>]>>;
     robot: z.ZodLiteral<"/http/import">;
     url: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>;
-    url_delimiter: z.ZodDefault<z.ZodString>;
-    headers: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>]>, z.ZodString]>>;
-    fail_fast: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    url_delimiter: z.ZodPrefault<z.ZodString>;
+    headers: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>]>, z.ZodString]>>;
+    fail_fast: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     max_file_size: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    return_file_stubs: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    return_file_stubs: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotHttpImportInstructions = InterpolatableRobotHttpImportInstructionsInput;
 export type InterpolatableRobotHttpImportInstructionsInput = z.input<typeof interpolatableRobotHttpImportInstructionsSchema>;
 export declare const interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         import: "import";
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
-    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    import_on_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
     }>]>>]>>;
     robot: z.ZodLiteral<"/http/import">;
-    url_delimiter: z.ZodDefault<z.ZodString>;
-    headers: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>]>, z.ZodString]>>;
-    fail_fast: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    url_delimiter: z.ZodPrefault<z.ZodString>;
+    headers: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>]>, z.ZodString]>>;
+    fail_fast: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     max_file_size: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    return_file_stubs: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    return_file_stubs: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -166,11 +170,12 @@ export declare const interpolatableRobotHttpImportInstructionsWithHiddenFieldsSc
     }, z.core.$strict>]>>;
     force_original_id: z.ZodOptional<z.ZodString>;
     force_name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
     credentials: z.ZodOptional<z.ZodString>;
     bucket: z.ZodOptional<z.ZodString>;
     url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotHttpImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema>;
 export type InterpolatableRobotHttpImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema>;
+export declare const robotDefinition: RobotSchemaPair<typeof interpolatableRobotHttpImportInstructionsSchema, typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema>;
 //# sourceMappingURL=http-import.d.ts.map

package/dist/v4/robots/http-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/http-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAiClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoFnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiB1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"http-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/http-import.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAEpF,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAc1B,eAAO,MAAM,IAAI,EAAE,cAkBlB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsFnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAe1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,+CAA+C,EACtD,OAAO,+DAA+D,CAKvE,CAAA"}

package/dist/v4/robots/http-import.js

@@ -1,9 +1,9 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, return_file_stubs, robotBase, robotImport, robotUseWithHiddenFields, } from "./_instructions-primitives.js";
+import { httpImportRobotErrors } from "../responseErrors/HttpImportRobot.js";
+import { httpHeaderSafetyDescription, httpUrlSchema, interpolateRobot, return_file_stubs, robotBase, robotImport, robotImportMeta, robotUseWithHiddenFields, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
+    ...robotImportMeta,
     example_code: {
         steps: {
             imported: {
@@ -13,32 +13,19 @@ export const meta = {
         },
     },
     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:
 
@@ -49,9 +36,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
@@ -77,6 +66,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.
@@ -87,18 +78,16 @@ when different URLs need different headers.
         .describe(`
 Disable the internal retry mechanism, and fail immediately if a resource can't be imported. This can be useful for performance critical applications.
 `),
-    max_file_size: z
+    max_file_size: optionalWithV3Semantics(z
         .number()
         .int()
-        .positive()
-        .optional()
+        .positive())
         .describe(`
 Maximum allowed size in bytes for each imported file. If the remote server reports a larger file size, the import is rejected before the download starts. If the remote server does not report a size upfront, the download is aborted once this limit is exceeded.
 `),
     return_file_stubs,
-    range: z
-        .union([z.string(), z.array(z.string())])
-        .optional()
+    range: optionalWithV3Semantics(z
+        .union([z.string(), z.array(z.string())]))
         .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.
 
@@ -122,20 +111,23 @@ Allows you to specify one or more byte ranges to import from the file. The serve
 export const robotHttpImportInstructionsWithHiddenFieldsSchema = robotHttpImportInstructionsSchema
     .merge(robotUseWithHiddenFields)
     .extend({
-    force_original_id: z.string().optional(),
-    force_name: z
-        .union([z.string(), z.record(z.string(), z.string())])
-        .optional()
+    force_original_id: optionalWithV3Semantics(z.string()),
+    force_name: optionalWithV3Semantics(z
+        .union([z.string(), z.record(z.string(), z.string())]))
         .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
+    result: optionalWithV3Semantics(z
+        .union([z.literal('debug'), robotHttpImportInstructionsSchema.shape.result])),
+    credentials: optionalWithV3Semantics(z.string()), // For test purposes
+    bucket: optionalWithV3Semantics(z.string()), // For test purposes
     // Override url to support relative URLs in tests with bucket
-    url: z.union([z.string(), z.array(z.string())]).optional(),
+    url: optionalWithV3Semantics(z.union([z.string(), z.array(z.string())])),
 });
 export const interpolatableRobotHttpImportInstructionsSchema = interpolateRobot(robotHttpImportInstructionsSchema);
 export const interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotHttpImportInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = {
+    meta,
+    interpolatable: interpolatableRobotHttpImportInstructionsSchema,
+    interpolatableWithHiddenFields: interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema,
+};