@transloadit/zod 4.1.5 → 4.1.6

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

@@ -0,0 +1,215 @@
+import { z } from 'zod/v3';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotHttpImportInstructionsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+    queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+} & {
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+} & {
+    robot: z.ZodLiteral<"/http/import">;
+    url: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    url_delimiter: z.ZodDefault<z.ZodString>;
+    headers: z.ZodDefault<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>, "many">, z.ZodString]>>;
+    import_on_errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    fail_fast: z.ZodDefault<z.ZodBoolean>;
+    return_file_stubs: z.ZodDefault<z.ZodBoolean>;
+    range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+}, "strict", z.ZodTypeAny, {
+    url: string | string[];
+    robot: "/http/import";
+    result: boolean;
+    force_accept: boolean;
+    ignore_errors: string[];
+    force_name: string | string[] | null;
+    headers: string | string[] | Record<string, string>[];
+    return_file_stubs: boolean;
+    url_delimiter: string;
+    import_on_errors: string[];
+    fail_fast: boolean;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+    range?: string | string[] | undefined;
+}, {
+    url: string | string[];
+    robot: "/http/import";
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    queue?: "batch" | undefined;
+    force_accept?: boolean | undefined;
+    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | string[] | null | undefined;
+    headers?: string | string[] | Record<string, string>[] | undefined;
+    return_file_stubs?: boolean | undefined;
+    url_delimiter?: string | undefined;
+    import_on_errors?: string[] | undefined;
+    fail_fast?: boolean | undefined;
+    range?: string | string[] | undefined;
+}>;
+export declare const robotHttpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    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", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+    robot: z.ZodLiteral<"/http/import">;
+    url_delimiter: z.ZodDefault<z.ZodString>;
+    headers: z.ZodDefault<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>, "many">, z.ZodString]>>;
+    import_on_errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    fail_fast: z.ZodDefault<z.ZodBoolean>;
+    return_file_stubs: z.ZodDefault<z.ZodBoolean>;
+    range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+} & {
+    force_original_id: z.ZodOptional<z.ZodString>;
+    force_name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+}, "strict", z.ZodTypeAny, {
+    robot: "/http/import";
+    force_accept: boolean;
+    ignore_errors: string[];
+    headers: string | string[] | Record<string, string>[];
+    return_file_stubs: boolean;
+    url_delimiter: string;
+    import_on_errors: string[];
+    fail_fast: boolean;
+    url?: string | string[] | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
+    queue?: "batch" | undefined;
+    force_name?: string | Record<string, string> | undefined;
+    credentials?: string | undefined;
+    bucket?: string | undefined;
+    range?: string | string[] | undefined;
+    force_original_id?: string | undefined;
+}, {
+    robot: "/http/import";
+    url?: string | string[] | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
+    queue?: "batch" | undefined;
+    force_accept?: boolean | undefined;
+    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | Record<string, string> | undefined;
+    credentials?: string | undefined;
+    bucket?: string | undefined;
+    headers?: string | string[] | Record<string, string>[] | undefined;
+    return_file_stubs?: boolean | undefined;
+    url_delimiter?: string | undefined;
+    import_on_errors?: string[] | undefined;
+    fail_fast?: boolean | undefined;
+    range?: string | string[] | undefined;
+    force_original_id?: string | undefined;
+}>;
+export type RobotHttpImportInstructions = z.infer<typeof robotHttpImportInstructionsSchema>;
+export type RobotHttpImportInstructionsWithHiddenFields = z.infer<typeof robotHttpImportInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotHttpImportInstructionsSchema: z.ZodObject<{
+    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">]>]>>;
+    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]>>;
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    robot: z.ZodLiteral<"/http/import">;
+    url: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>;
+    url_delimiter: z.ZodDefault<z.ZodString>;
+    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.ZodString>, "many">]>, z.ZodString]>>;
+    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    fail_fast: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    return_file_stubs: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+}, "strict", z.ZodTypeAny, {
+    url: string | string[];
+    robot: "/http/import";
+    result: string | boolean;
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    force_name: string | string[] | null;
+    headers: string | string[] | Record<string, string>[];
+    return_file_stubs: string | boolean;
+    url_delimiter: string;
+    import_on_errors: string | string[];
+    fail_fast: string | boolean;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    range?: string | string[] | undefined;
+}, {
+    url: string | string[];
+    robot: "/http/import";
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    result?: string | boolean | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | string[] | null | undefined;
+    headers?: string | string[] | Record<string, string>[] | undefined;
+    return_file_stubs?: string | boolean | undefined;
+    url_delimiter?: string | undefined;
+    import_on_errors?: string | string[] | undefined;
+    fail_fast?: string | boolean | undefined;
+    range?: string | string[] | undefined;
+}>;
+export type InterpolatableRobotHttpImportInstructions = InterpolatableRobotHttpImportInstructionsInput;
+export type InterpolatableRobotHttpImportInstructionsInput = z.input<typeof interpolatableRobotHttpImportInstructionsSchema>;
+export declare const interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    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">]>]>>;
+    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", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    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, "many">]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>, "many">]>, z.ZodString]>>;
+    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    fail_fast: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    return_file_stubs: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    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]>>]>>;
+    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, "many">]>]>>;
+}, "strict", z.ZodTypeAny, {
+    robot: "/http/import";
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    headers: string | string[] | Record<string, string>[];
+    return_file_stubs: string | boolean;
+    url_delimiter: string;
+    import_on_errors: string | string[];
+    fail_fast: string | boolean;
+    url?: string | string[] | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    result?: string | boolean | undefined;
+    queue?: string | undefined;
+    force_name?: string | Record<string, string> | undefined;
+    credentials?: string | undefined;
+    bucket?: string | undefined;
+    range?: string | string[] | undefined;
+    force_original_id?: string | undefined;
+}, {
+    robot: "/http/import";
+    url?: string | string[] | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    result?: string | boolean | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | Record<string, string> | undefined;
+    credentials?: string | undefined;
+    bucket?: string | undefined;
+    headers?: string | string[] | Record<string, string>[] | undefined;
+    return_file_stubs?: string | boolean | undefined;
+    url_delimiter?: string | undefined;
+    import_on_errors?: string | string[] | undefined;
+    fail_fast?: string | boolean | undefined;
+    range?: string | string[] | undefined;
+    force_original_id?: string | undefined;
+}>;
+export type InterpolatableRobotHttpImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotHttpImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=http-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-import.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/http-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,eAAO,MAAM,IAAI,EAAE,cAkClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8EnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,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"}

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

@@ -0,0 +1,134 @@
+import { z } from 'zod/v3';
+import { interpolateRobot, return_file_stubs, robotBase, robotImport, } from "./_instructions-primitives.js";
+export const meta = {
+    allowed_for_url_transform: true,
+    bytescount: 10,
+    discount_factor: 0.1,
+    discount_pct: 90,
+    example_code: {
+        steps: {
+            imported: {
+                robot: '/http/import',
+                url: 'https://demos.transloadit.com/inputs/chameleon.jpg',
+            },
+        },
+    },
+    example_code_description: 'Import an image from a specific URL:',
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Importing',
+    purpose_sentence: 'imports any file that is publicly available via a web URL into Transloadit',
+    purpose_verb: 'import',
+    purpose_word: 'Webservers',
+    purpose_words: 'Import files from web servers',
+    service_slug: 'file-importing',
+    slot_count: 10,
+    title: 'Import files from web servers',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+    name: 'HttpImportRobot',
+    priceFactor: 10,
+    queueSlotCount: 10,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: false,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+    stage: 'ga',
+};
+export const robotHttpImportInstructionsSchema = robotBase
+    .merge(robotImport)
+    .extend({
+    robot: z.literal('/http/import').describe(`
+The result of this <dfn>Robot</dfn> will carry a field \`import_url\` in their metadata, which references the URL from which they were imported. Further conversion results that use this file will also carry this \`import_url\` field. This allows you to to match conversion results with the original import URL that you used.
+
+This <dfn>Robot</dfn> knows to interpret links to files on these services:
+
+- Dropbox
+- Google Drive
+- Google Docs
+- OneDrive
+
+Instead of downloading the HTML page previewing the file, the actual file itself will be imported.
+`),
+    url: z.union([z.string().url(), z.array(z.string().url())]).describe(`
+The URL from which the file to be imported can be retrieved.
+
+You can also specify an array of URLs or a string of \`|\` delimited URLs to import several files at once. Please also check the \`url_delimiter\` parameter for that.
+`),
+    url_delimiter: z
+        .string()
+        .default('|')
+        .describe(`
+Provides the delimiter that is used to split the URLs in your \`url\` parameter value.
+`),
+    headers: z
+        .union([
+        z.array(z.string()),
+        z.array(z.record(z.string())),
+        z.string(), // For JSON strings like '{"X-Database":"volt"}'
+    ])
+        .default([])
+        .describe(`
+Custom headers to be sent for file import.
+
+This is an empty array by default, such that no additional headers except the necessary ones (e.g. Host) are sent.
+
+Headers can be specified as:
+- An array of strings in the format "Header-Name: value"
+- An array of objects with header names as keys and values as values
+- A JSON string that will be parsed into an object
+`),
+    import_on_errors: z
+        .array(z.string())
+        .default([])
+        .describe(`
+Setting this to \`"meta"\` will still import the file on metadata extraction errors. \`ignore_errors\` is similar, it also ignores the error and makes sure the Robot doesn't stop, but it doesn't import the file.
+`),
+    fail_fast: z
+        .boolean()
+        .default(false)
+        .describe(`
+Disable the internal retry mechanism, and fail immediately if a resource can't be imported. This can be useful for performance critical applications.
+`),
+    return_file_stubs,
+    range: z
+        .union([z.string(), z.array(z.string())])
+        .optional()
+        .describe(`
+Allows you to specify one or more byte ranges to import from the file. The server must support range requests for this to work.
+
+**Single range**: Use a string like \`"0-99"\` to import bytes 0-99 (the first 100 bytes).
+
+**Multiple ranges**: Use an array like \`["0-99", "200-299"]\` to import multiple separate ranges. The resulting file will contain all requested ranges concatenated together, with zero bytes (\\0) filling any gaps between non-contiguous ranges.
+
+**Range formats**:
+- \`"0-99"\`: Bytes 0 through 99 (inclusive)
+- \`"100-199"\`: Bytes 100 through 199 (inclusive)
+- \`"-100"\`: The last 100 bytes of the file
+
+**Important notes**:
+- The server must support HTTP range requests (respond with 206 Partial Content)
+- If the server doesn't support range requests, the entire file will be imported instead
+- Overlapping ranges are allowed and will be included as requested
+- The resulting file size will be the highest byte position requested, with gaps filled with zero bytes
+`),
+})
+    .strict();
+export const robotHttpImportInstructionsWithHiddenFieldsSchema = robotHttpImportInstructionsSchema.extend({
+    force_original_id: z.string().optional(),
+    force_name: z
+        .union([z.string(), z.record(z.string())])
+        .optional()
+        .describe(`
+Force a specific filename for imported files. Can be a string to apply to all imports, or an object mapping URLs to filenames.
+`),
+    result: z
+        .union([z.literal('debug'), robotHttpImportInstructionsSchema.shape.result])
+        .optional(),
+    credentials: z.string().optional(), // For test purposes
+    bucket: z.string().optional(), // For test purposes
+    // Override url to support relative URLs in tests with bucket
+    url: z.union([z.string(), z.array(z.string())]).optional(),
+});
+export const interpolatableRobotHttpImportInstructionsSchema = interpolateRobot(robotHttpImportInstructionsSchema);
+export const interpolatableRobotHttpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotHttpImportInstructionsWithHiddenFieldsSchema);