@transloadit/zod 4.1.3 → 4.1.5

package/dist/v4/robots/edgly-deliver.js

@@ -1,45 +0,0 @@
-import { z } from 'zod/v4';
-import { interpolateRobot, robotBase } from "./_instructions-primitives.js";
-export const meta = {
-    allowed_for_url_transform: false,
-    bytescount: 20,
-    discount_factor: 0.05,
-    discount_pct: 95,
-    minimum_charge: 102400,
-    output_factor: 1,
-    override_lvl1: 'Content Delivery',
-    purpose_sentence: 'caches and delivers files globally',
-    purpose_verb: 'cache & deliver',
-    purpose_word: 'Cache and deliver files',
-    purpose_words: 'Cache and deliver files globally',
-    service_slug: 'content-delivery',
-    slot_count: 0,
-    title: 'Cache and deliver files globally',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
-    name: 'EdglyDeliverRobot',
-    priceFactor: 20,
-    queueSlotCount: 0,
-    minimumCharge: 102400,
-    downloadInputFiles: false,
-    preserveInputFileUrls: true,
-    isAllowedForUrlTransform: false,
-    trackOutputFileSize: false,
-    isInternal: true,
-    stage: 'removed',
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-};
-export const robotEdglyDeliverInstructionsSchema = robotBase
-    .extend({
-    robot: z.literal('/edgly/deliver').describe(`
-When you want Transloadit to tranform files on the fly, this <dfn>Robot</dfn> can cache and deliver the results close to your end-user, saving on latency and encoding volume. The use of this <dfn>Robot</dfn> is implicit when you use the <code>edgly.net</code> domain.
-`),
-})
-    .strict();
-export const robotEdglyDeliverInstructionsWithHiddenFieldsSchema = robotEdglyDeliverInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotEdglyDeliverInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotEdglyDeliverInstructionsSchema = interpolateRobot(robotEdglyDeliverInstructionsSchema);
-export const interpolatableRobotEdglyDeliverInstructionsWithHiddenFieldsSchema = interpolateRobot(robotEdglyDeliverInstructionsWithHiddenFieldsSchema);

package/dist/v4/robots/file-compress.d.ts

@@ -1,170 +0,0 @@
-import { z } from 'zod/v4';
-import type { RobotMetaInput } from './_instructions-primitives.ts';
-export declare const meta: RobotMetaInput;
-export declare const robotFileCompressInstructionsSchema: z.ZodObject<{
-    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
-    result: z.ZodDefault<z.ZodBoolean>;
-    queue: z.ZodOptional<z.ZodEnum<{
-        batch: "batch";
-    }>>;
-    force_accept: z.ZodDefault<z.ZodBoolean>;
-    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/compress">;
-    format: z.ZodDefault<z.ZodEnum<{
-        zip: "zip";
-        tar: "tar";
-    }>>;
-    gzip: z.ZodDefault<z.ZodBoolean>;
-    password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    compression_level: z.ZodDefault<z.ZodNumber>;
-    file_layout: z.ZodDefault<z.ZodEnum<{
-        advanced: "advanced";
-        simple: "simple";
-        "relative-path": "relative-path";
-    }>>;
-    archive_name: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
-    queue: z.ZodOptional<z.ZodEnum<{
-        batch: "batch";
-    }>>;
-    force_accept: z.ZodDefault<z.ZodBoolean>;
-    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/compress">;
-    format: z.ZodDefault<z.ZodEnum<{
-        zip: "zip";
-        tar: "tar";
-    }>>;
-    gzip: z.ZodDefault<z.ZodBoolean>;
-    password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    compression_level: z.ZodDefault<z.ZodNumber>;
-    file_layout: z.ZodDefault<z.ZodEnum<{
-        advanced: "advanced";
-        simple: "simple";
-        "relative-path": "relative-path";
-    }>>;
-    archive_name: z.ZodOptional<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotFileCompressInstructions = z.infer<typeof robotFileCompressInstructionsSchema>;
-export type RobotFileCompressInstructionsWithHiddenFields = z.infer<typeof robotFileCompressInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileCompressInstructionsSchema: 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>]>]>>;
-    result: z.ZodDefault<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<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/compress">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        zip: "zip";
-        tar: "tar";
-    }>]>>;
-    gzip: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    compression_level: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    file_layout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        advanced: "advanced";
-        simple: "simple";
-        "relative-path": "relative-path";
-    }>]>>;
-    archive_name: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type InterpolatableRobotFileCompressInstructions = InterpolatableRobotFileCompressInstructionsInput;
-export type InterpolatableRobotFileCompressInstructionsInput = z.input<typeof interpolatableRobotFileCompressInstructionsSchema>;
-export declare const interpolatableRobotFileCompressInstructionsWithHiddenFieldsSchema: 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>]>]>>;
-    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<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/compress">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        zip: "zip";
-        tar: "tar";
-    }>]>>;
-    gzip: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    compression_level: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    file_layout: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        advanced: "advanced";
-        simple: "simple";
-        "relative-path": "relative-path";
-    }>]>>;
-    archive_name: z.ZodOptional<z.ZodString>;
-    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 InterpolatableRobotFileCompressInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileCompressInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileCompressInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileCompressInstructionsWithHiddenFieldsSchema>;
-//# sourceMappingURL=file-compress.d.ts.map

package/dist/v4/robots/file-compress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-compress.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/file-compress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cA0ElB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqDrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/v4/robots/file-compress.js

@@ -1,138 +0,0 @@
-import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
-export const meta = {
-    allowed_for_url_transform: false,
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            compressed: {
-                robot: '/file/compress',
-                use: {
-                    steps: [':original'],
-                    bundle_steps: true,
-                },
-                format: 'zip',
-            },
-        },
-    },
-    example_code_description: 'Compress uploaded files into a ZIP archive:',
-    extended_description: `
-### Archive structure for the \`"advanced"\` file layout.
-
-There are a few things that we kept in mind when designing the \`"advanced"\` archive structure:
-
-- There could be naming collisions.
-- You want to know which <dfn>Step</dfn> a result file belongs to.
-- You want to know from which originally uploaded file a result file was generated.
-- Ideally, you want subfolders for a better structure of files.
-
-To achieve all this, we have created the following archive file structure.
-
-- There is a subfolder for each <dfn>Step</dfn> name that has result files in the archive.
-- Files are named according to the first two letters of the unique original prefix + "_" + the first two letters of the unique prefix + "_" + the original file name. If you do not know what the original prefixes are, please check [our available Assembly variables](/docs/topics/assembly-instructions/#assembly-variables) and look for \`\${unique_original_prefix}\` and \`\${unique_prefix}\`.
-- Files that belong to the \`:original\` <dfn>Step</dfn> (originally uploaded files) do **not** include the first two letters of the \`unique_original_prefix\`.
-- If you are dealing with thumbnails from [🤖/video/thumbs](/docs/robots/video-thumbs/), there is an additional digit representing the order in the file name.
-
-Here is an example:
-
-\`\`\`yaml
-":original":
-  - gh_a.mov          # "gh" are the first 2 letters of the unique prefix.
-                      # "a.mov" was the file name of the uploaded file.
-  - ff_b.mov
-"thumbed":
-  - gh_e8_thumb_1.jpg # "gh" is the unique original prefix, meaning it's a result of a.mov.
-                      # "e8" is the file's unique prefix.
-                      # The "1" shows the thumbnail order.
-  - gh_cv_thumb_2.jpg
-  - ff_9b_thumb_3.jpg
-"resized":
-  - gh_ll_thumb.jpg
-  - gh_df_thumb.jpg
-  - ff_jk_thumb.jpg   # is a child of b.mov, as it starts with "ff"
-\`\`\`
-`,
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Compressing',
-    purpose_sentence: 'creates archives of files or file conversion results',
-    purpose_verb: 'compress',
-    purpose_word: 'compress',
-    purpose_words: 'Compress files',
-    service_slug: 'file-compressing',
-    slot_count: 15,
-    title: 'Compress files',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
-    name: 'FileCompressRobot',
-    priceFactor: 1,
-    queueSlotCount: 15,
-    isAllowedForUrlTransform: false,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
-};
-export const robotFileCompressInstructionsSchema = robotBase
-    .merge(robotUse)
-    .extend({
-    robot: z.literal('/file/compress'),
-    format: z
-        .enum(['tar', 'zip'])
-        .default('tar')
-        .describe(`
-The format of the archive to be created. Supported values are \`"tar"\` and \`"zip"\`.
-
-Note that \`"tar"\` without setting \`gzip\` to \`true\` results in an archive that's not compressed in any way.
-`),
-    gzip: z
-        .boolean()
-        .default(false)
-        .describe(`
-Determines if the result archive should also be gzipped. Gzip compression is only applied if you use the \`"tar"\` format.
-`),
-    password: z
-        .string()
-        .nullable()
-        .default(null)
-        .describe(`
-This allows you to encrypt all archive contents with a password and thereby protect it against unauthorized use. To unzip the archive, the user will need to provide the password in a text input field prompt.
-
-This parameter has no effect if the format parameter is anything other than \`"zip"\`.
-`),
-    compression_level: z
-        .number()
-        .int()
-        .min(-9)
-        .max(0)
-        .default(-6)
-        .describe(`
-Determines how fiercely to try to compress the archive. \`-0\` is compressionless, which is suitable for media that is already compressed. \`-1\` is fastest with lowest compression. \`-9\` is slowest with the highest compression.
-
-If you are using \`-0\` in combination with the \`tar\` format with \`gzip\` enabled, consider setting \`gzip: false\` instead. This results in a plain Tar archive, meaning it already has no compression.
-`),
-    file_layout: z
-        .enum(['advanced', 'simple', 'relative-path'])
-        .default('advanced')
-        .describe(`
-Determines if the result archive should contain all files in one directory (value for this is \`"simple"\`) or in subfolders according to the explanation below (value for this is \`"advanced"\`). The \`"relative-path"\` option preserves the relative directory structure of the input files.
-
-Files with same names are numbered in the \`"simple"\` file layout to avoid naming collisions.
-`),
-    archive_name: z
-        .string()
-        .optional()
-        .describe(`
-The name of the archive file to be created (without the file extension).
-`),
-})
-    .strict();
-export const robotFileCompressInstructionsWithHiddenFieldsSchema = robotFileCompressInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotFileCompressInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotFileCompressInstructionsSchema = interpolateRobot(robotFileCompressInstructionsSchema);
-export const interpolatableRobotFileCompressInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileCompressInstructionsWithHiddenFieldsSchema);

package/dist/v4/robots/file-decompress.d.ts

@@ -1,118 +0,0 @@
-import { z } from 'zod/v4';
-import type { RobotMetaInput } from './_instructions-primitives.ts';
-export declare const meta: RobotMetaInput;
-export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
-    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
-    result: z.ZodDefault<z.ZodBoolean>;
-    queue: z.ZodOptional<z.ZodEnum<{
-        batch: "batch";
-    }>>;
-    force_accept: z.ZodDefault<z.ZodBoolean>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/decompress">;
-    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<("meta" | "execute")[], boolean | ("meta" | "execute")[]>>>;
-}, z.core.$strict>;
-export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
-    queue: z.ZodOptional<z.ZodEnum<{
-        batch: "batch";
-    }>>;
-    force_accept: z.ZodDefault<z.ZodBoolean>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/decompress">;
-    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<("meta" | "execute")[], boolean | ("meta" | "execute")[]>>>;
-    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotFileDecompressInstructions = z.infer<typeof robotFileDecompressInstructionsSchema>;
-export type RobotFileDecompressInstructionsWithHiddenFields = z.infer<typeof robotFileDecompressInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileDecompressInstructionsSchema: 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>]>]>>;
-    result: z.ZodDefault<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]>>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/decompress">;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<("meta" | "execute")[], boolean | ("meta" | "execute")[]>>]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotFileDecompressInstructions = InterpolatableRobotFileDecompressInstructionsInput;
-export type InterpolatableRobotFileDecompressInstructionsInput = z.input<typeof interpolatableRobotFileDecompressInstructionsSchema>;
-export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema: 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>]>]>>;
-    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        batch: "batch";
-    }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        fields: z.ZodOptional<z.ZodString>;
-        as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>]>, z.ZodObject<{
-        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            fields: z.ZodOptional<z.ZodString>;
-            as: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>]>;
-        bundle_steps: z.ZodOptional<z.ZodBoolean>;
-        group_by_original: z.ZodOptional<z.ZodBoolean>;
-        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>]>>;
-    robot: z.ZodLiteral<"/file/decompress">;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
-        meta: "meta";
-        execute: "execute";
-    }>>]>, z.ZodTransform<("meta" | "execute")[], boolean | ("meta" | "execute")[]>>]>>;
-    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 InterpolatableRobotFileDecompressInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileDecompressInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema>;
-//# sourceMappingURL=file-decompress.d.ts.map

package/dist/v4/robots/file-decompress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-decompress.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/file-decompress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkDvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK9D,CAAA;AAEJ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AACnG,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/D,CAAA;AACD,MAAM,MAAM,6CAA6C,GACvD,kDAAkD,CAAA;AAEpD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/E,CAAA;AACD,MAAM,MAAM,6DAA6D,GAAG,CAAC,CAAC,KAAK,CACjF,OAAO,mEAAmE,CAC3E,CAAA;AACD,MAAM,MAAM,kEAAkE,GAAG,CAAC,CAAC,KAAK,CACtF,OAAO,mEAAmE,CAC3E,CAAA"}

package/dist/v4/robots/file-decompress.js

@@ -1,93 +0,0 @@
-import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
-export const meta = {
-    allowed_for_url_transform: true,
-    bytescount: 1,
-    discount_factor: 0.8,
-    discount_pct: 20,
-    example_code: {
-        steps: {
-            decompressed: {
-                robot: '/file/decompress',
-                use: ':original',
-            },
-        },
-    },
-    example_code_description: 'Decompress an uploaded archive:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Compressing',
-    purpose_sentence: 'extracts entire archives of files to be consumed by other Robots or exported as individual files',
-    purpose_verb: 'decompress',
-    purpose_word: 'decompress',
-    purpose_words: 'Decompress archives',
-    service_slug: 'file-compressing',
-    slot_count: 10,
-    title: 'Decompress archives',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
-    name: 'FileDecompressRobot',
-    priceFactor: 1.25,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-    stage: 'ga',
-};
-export const robotFileDecompressInstructionsSchema = robotBase
-    .merge(robotUse)
-    .extend({
-    robot: z.literal('/file/decompress').describe(`
-This Robot supports the following archive formats:
-
-- ZIP archives (with uncompressed or "deflate"-compressed entries)
-- 7-Zip archives
-- RAR archives
-- GNU tar format (including GNU long filenames, long link names, and sparse files)
-- Solaris 9 extended tar format (including ACLs)
-- Old V7 tar archives
-- POSIX ustar
-- POSIX pax interchange format
-- POSIX octet-oriented cpio
-- SVR4 ASCII cpio
-- POSIX octet-oriented cpio
-- Binary cpio (big-endian or little-endian)
-- ISO9660 CD-ROM images (with optional Rockridge or Joliet extensions)
-- GNU and BSD "ar" archives
-- "mtree" format
-- Microsoft CAB format
-- LHA and LZH archives
-- XAR archives
-
-This <dfn>Robot</dfn> also detects and handles any of the following before evaluating the archive file:
-
-- uuencoded files
-- Files with RPM wrapper
-- gzip compression
-- bzip2 compression
-- compress/LZW compression
-- lzma, lzip, and xz compression
-
-For security reasons, archives that contain symlinks to outside the archived dir, will error out the <dfn>Assembly</dfn>. Decompressing password-protected archives (encrypted archives) is currently not fully supported but will not cause an <dfn>Assembly</dfn> to fail.
-`),
-    ignore_errors: z
-        .union([z.boolean(), z.array(z.enum(['meta', 'execute']))])
-        .transform((ignoreErrors) => ignoreErrors === true ? ['meta', 'execute'] : ignoreErrors === false ? [] : ignoreErrors)
-        .default([])
-        .describe(`
-A possible array member is only \`"meta"\`.
-
-You might see an error when trying to extract metadata from the files inside your archive. This happens, for example, for files with a size of zero bytes. Setting this to \`true\` will cause the <dfn>Robot</dfn> to not stop the file decompression (and the entire <dfn>Assembly</dfn>) when that happens.
-
-To keep backwards compatibility, setting this parameter to \`true\` will set it to \`["meta"]\` internally.
-`),
-})
-    .strict();
-export const robotFileDecompressInstructionsWithHiddenFieldsSchema = robotFileDecompressInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotFileDecompressInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotFileDecompressInstructionsSchema = interpolateRobot(robotFileDecompressInstructionsSchema);
-export const interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileDecompressInstructionsWithHiddenFieldsSchema);