@transloadit/zod 4.1.3 → 4.1.5

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

@@ -1,477 +0,0 @@
-import { z } from 'zod/v3';
-import type { RobotMetaInput } from './_instructions-primitives.ts';
-export declare const meta: RobotMetaInput;
-export declare const robotFileCompressInstructionsSchema: 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>;
-    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<"/file/compress">;
-    format: z.ZodDefault<z.ZodEnum<["tar", "zip"]>>;
-    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", "simple", "relative-path"]>>;
-    archive_name: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    result: boolean;
-    force_accept: boolean;
-    ignore_errors: string[];
-    password: string | null;
-    robot: "/file/compress";
-    format: "tar" | "zip";
-    gzip: boolean;
-    compression_level: number;
-    file_layout: "advanced" | "simple" | "relative-path";
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    queue?: "batch" | 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;
-    archive_name?: string | undefined;
-}, {
-    robot: "/file/compress";
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | undefined;
-    queue?: "batch" | undefined;
-    force_accept?: boolean | undefined;
-    ignore_errors?: boolean | ("meta" | "execute")[] | 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;
-    password?: string | null | undefined;
-    format?: "tar" | "zip" | undefined;
-    gzip?: boolean | undefined;
-    compression_level?: number | undefined;
-    file_layout?: "advanced" | "simple" | "relative-path" | undefined;
-    archive_name?: string | undefined;
-}>;
-export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: 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", "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<"/file/compress">;
-    format: z.ZodDefault<z.ZodEnum<["tar", "zip"]>>;
-    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", "simple", "relative-path"]>>;
-    archive_name: z.ZodOptional<z.ZodString>;
-} & {
-    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, "strict", z.ZodTypeAny, {
-    force_accept: boolean;
-    ignore_errors: string[];
-    password: string | null;
-    robot: "/file/compress";
-    format: "tar" | "zip";
-    gzip: boolean;
-    compression_level: number;
-    file_layout: "advanced" | "simple" | "relative-path";
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
-    queue?: "batch" | 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;
-    archive_name?: string | undefined;
-}, {
-    robot: "/file/compress";
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
-    queue?: "batch" | undefined;
-    force_accept?: boolean | undefined;
-    ignore_errors?: boolean | ("meta" | "execute")[] | 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;
-    password?: string | null | undefined;
-    format?: "tar" | "zip" | undefined;
-    gzip?: boolean | undefined;
-    compression_level?: number | undefined;
-    file_layout?: "advanced" | "simple" | "relative-path" | undefined;
-    archive_name?: string | undefined;
-}>;
-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, "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]>>;
-    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<"/file/compress">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["tar", "zip"]>]>>;
-    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", "simple", "relative-path"]>]>>;
-    archive_name: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    result: string | boolean;
-    force_accept: string | boolean;
-    ignore_errors: string | string[];
-    password: string | null;
-    robot: "/file/compress";
-    format: string;
-    gzip: string | boolean;
-    compression_level: string | number;
-    file_layout: string;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    queue?: string | 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;
-    archive_name?: string | undefined;
-}, {
-    robot: "/file/compress";
-    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 | ("meta" | "execute")[] | 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;
-    password?: string | null | undefined;
-    format?: string | undefined;
-    gzip?: string | boolean | undefined;
-    compression_level?: string | number | undefined;
-    file_layout?: string | undefined;
-    archive_name?: string | undefined;
-}>;
-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, "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", "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<"/file/compress">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["tar", "zip"]>]>>;
-    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", "simple", "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]>>]>>;
-}, "strict", z.ZodTypeAny, {
-    force_accept: string | boolean;
-    ignore_errors: string | string[];
-    password: string | null;
-    robot: "/file/compress";
-    format: string;
-    gzip: string | boolean;
-    compression_level: string | number;
-    file_layout: string;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
-    queue?: string | 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;
-    archive_name?: string | undefined;
-}, {
-    robot: "/file/compress";
-    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 | ("meta" | "execute")[] | 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;
-    password?: string | null | undefined;
-    format?: string | undefined;
-    gzip?: string | boolean | undefined;
-    compression_level?: string | number | undefined;
-    file_layout?: string | undefined;
-    archive_name?: string | undefined;
-}>;
-export type InterpolatableRobotFileCompressInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileCompressInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileCompressInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileCompressInstructionsWithHiddenFieldsSchema>;
-//# sourceMappingURL=file-compress.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"file-compress.d.ts","sourceRoot":"","sources":["../../../src/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,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/v3/robots/file-compress.js

@@ -1,138 +0,0 @@
-import { z } from 'zod/v3';
-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);