@transloadit/zod 4.1.3 → 4.1.5

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

@@ -1,215 +0,0 @@
-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[];
-    result: boolean;
-    force_accept: boolean;
-    ignore_errors: string[];
-    force_name: string | string[] | null;
-    robot: "/http/import";
-    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, {
-    force_accept: boolean;
-    ignore_errors: string[];
-    robot: "/http/import";
-    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[];
-    result: string | boolean;
-    force_accept: string | boolean;
-    ignore_errors: string | string[];
-    force_name: string | string[] | null;
-    robot: "/http/import";
-    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, {
-    force_accept: string | boolean;
-    ignore_errors: string | string[];
-    robot: "/http/import";
-    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

@@ -1 +0,0 @@
-{"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

@@ -1,134 +0,0 @@
-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);