@transloadit/zod 4.4.1 → 5.0.0

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

@@ -1,9 +1,8 @@
 import { z } from 'zod/v3';
-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 +12,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 +35,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 +65,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.
@@ -139,3 +129,8 @@ Force a specific filename for imported files. Can be a string to apply to all im
 });
 export const interpolatableRobotHttpImportInstructionsSchema = interpolateRobot(robotHttpImportInstructionsSchema);
 export const interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotHttpImportInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = {
+    meta,
+    interpolatable: interpolatableRobotHttpImportInstructionsSchema,
+    interpolatableWithHiddenFields: interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema,
+};

package/dist/v3/robots/http-request.d.ts

@@ -0,0 +1,538 @@
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
+import { z } from 'zod/v3';
+export declare const meta: RobotMetaInput;
+export declare const robotHttpRequestInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+    queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
+} & {
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+} & {
+    robot: z.ZodLiteral<"/http/request">;
+    url: z.ZodEffects<z.ZodString, string, string>;
+    method: z.ZodDefault<z.ZodEnum<["DELETE", "GET", "PATCH", "POST", "PUT"]>>;
+    payload: z.ZodDefault<z.ZodEnum<["none", "metadata", "file", "files"]>>;
+    headers: z.ZodDefault<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodNull]>>, "many">, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodNull]>>, z.ZodString]>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    max_response_size: z.ZodDefault<z.ZodNumber>;
+    max_result_files: z.ZodDefault<z.ZodNumber>;
+    max_result_file_size: z.ZodDefault<z.ZodNumber>;
+    result_download_timeout: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    result: boolean;
+    robot: "/http/request";
+    user_meta: Record<string, unknown>;
+    force_accept: boolean;
+    ignore_errors: string[];
+    headers: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[];
+    method: "POST" | "DELETE" | "GET" | "PATCH" | "PUT";
+    payload: "file" | "none" | "metadata" | "files";
+    timeout: number;
+    max_response_size: number;
+    max_result_files: number;
+    max_result_file_size: number;
+    result_download_timeout: number;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+}, {
+    url: string;
+    robot: "/http/request";
+    result?: boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
+    force_accept?: boolean | undefined;
+    ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
+    headers?: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[] | undefined;
+    method?: "POST" | "DELETE" | "GET" | "PATCH" | "PUT" | undefined;
+    payload?: "file" | "none" | "metadata" | "files" | undefined;
+    timeout?: number | undefined;
+    max_response_size?: number | undefined;
+    max_result_files?: number | undefined;
+    max_result_file_size?: number | undefined;
+    result_download_timeout?: number | undefined;
+}>;
+export declare const robotDefinition: RobotDefinition<typeof robotHttpRequestInstructionsSchema.shape>;
+export declare const robotHttpRequestInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+    robot: z.ZodLiteral<"/http/request">;
+    url: z.ZodEffects<z.ZodString, string, string>;
+    method: z.ZodDefault<z.ZodEnum<["DELETE", "GET", "PATCH", "POST", "PUT"]>>;
+    payload: z.ZodDefault<z.ZodEnum<["none", "metadata", "file", "files"]>>;
+    headers: z.ZodDefault<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodNull]>>, "many">, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodNumber, z.ZodString, z.ZodNull]>>, z.ZodString]>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    max_response_size: z.ZodDefault<z.ZodNumber>;
+    max_result_files: z.ZodDefault<z.ZodNumber>;
+    max_result_file_size: z.ZodDefault<z.ZodNumber>;
+    result_download_timeout: z.ZodDefault<z.ZodNumber>;
+} & {
+    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    robot: "/http/request";
+    user_meta: Record<string, unknown>;
+    force_accept: boolean;
+    ignore_errors: string[];
+    headers: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[];
+    method: "POST" | "DELETE" | "GET" | "PATCH" | "PUT";
+    payload: "file" | "none" | "metadata" | "files";
+    timeout: number;
+    max_response_size: number;
+    max_result_files: number;
+    max_result_file_size: number;
+    result_download_timeout: number;
+    result?: boolean | "debug" | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+}, {
+    url: string;
+    robot: "/http/request";
+    result?: boolean | "debug" | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
+    force_accept?: boolean | undefined;
+    ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
+    headers?: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[] | undefined;
+    method?: "POST" | "DELETE" | "GET" | "PATCH" | "PUT" | undefined;
+    payload?: "file" | "none" | "metadata" | "files" | undefined;
+    timeout?: number | undefined;
+    max_response_size?: number | undefined;
+    max_result_files?: number | undefined;
+    max_result_file_size?: number | undefined;
+    result_download_timeout?: number | undefined;
+}>, interpolatableRobotHttpRequestInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+    robot: z.ZodLiteral<"/http/request">;
+    url: z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodString, string, string>]>;
+    method: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["DELETE", "GET", "PATCH", "POST", "PUT"]>]>>;
+    payload: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["none", "metadata", "file", "files"]>]>>;
+    headers: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodString, z.ZodNull]>>, "many">]>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodString, z.ZodNull]>>, z.ZodString]>>;
+    timeout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    max_response_size: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    max_result_files: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    max_result_file_size: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    result_download_timeout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    result: string | boolean;
+    robot: "/http/request";
+    user_meta: Record<string, unknown>;
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    headers: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[];
+    method: string;
+    payload: string;
+    timeout: string | number;
+    max_response_size: string | number;
+    max_result_files: string | number;
+    max_result_file_size: string | number;
+    result_download_timeout: string | number;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+}, {
+    url: string;
+    robot: "/http/request";
+    result?: string | boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    headers?: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[] | undefined;
+    method?: string | undefined;
+    payload?: string | undefined;
+    timeout?: string | number | undefined;
+    max_response_size?: string | number | undefined;
+    max_result_files?: string | number | undefined;
+    max_result_file_size?: string | number | undefined;
+    result_download_timeout?: string | number | undefined;
+}>, interpolatableRobotHttpRequestInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+    robot: z.ZodLiteral<"/http/request">;
+    url: z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodString, string, string>]>;
+    method: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["DELETE", "GET", "PATCH", "POST", "PUT"]>]>>;
+    payload: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["none", "metadata", "file", "files"]>]>>;
+    headers: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodString, z.ZodNull]>>, "many">]>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodString, z.ZodNull]>>, z.ZodString]>>;
+    timeout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    max_response_size: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    max_result_files: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    max_result_file_size: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    result_download_timeout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    robot: "/http/request";
+    user_meta: Record<string, unknown>;
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    headers: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[];
+    method: string;
+    payload: string;
+    timeout: string | number;
+    max_response_size: string | number;
+    max_result_files: string | number;
+    max_result_file_size: string | number;
+    result_download_timeout: string | number;
+    result?: string | boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+}, {
+    url: string;
+    robot: "/http/request";
+    result?: string | boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    headers?: string | string[] | Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[] | undefined;
+    method?: string | undefined;
+    payload?: string | undefined;
+    timeout?: string | number | undefined;
+    max_response_size?: string | number | undefined;
+    max_result_files?: string | number | undefined;
+    max_result_file_size?: string | number | undefined;
+    result_download_timeout?: string | number | undefined;
+}>;
+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'];
+export {};
+//# sourceMappingURL=http-request.d.ts.map

package/dist/v3/robots/http-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-request.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/http-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAiDlB,CAAA;AAGD,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0GpC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,kCAAkC,CAAC,KAAK,CACtC,CAAA;AAEvD,eAAO,MACa,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACpD,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAChC,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC/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"}