@transloadit/zod 4.5.0 → 5.0.1

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

@@ -1,39 +1,22 @@
 import { z } from 'zod/v3';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobot, robotBase, robotParameterDocs, robotProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 0.8,
-    discount_pct: 20,
-    example_code: {
-        steps: {
-            decompressed: {
-                robot: '/file/decompress',
-                use: ':original',
-            },
-        },
-    },
+    ...robotProcessingMeta,
+    example_code: createProcessingExample('decompressed', '/file/decompress'),
     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',
 };
+// Keep the inherited runtime contract while appending guidance specific to archive metadata.
 export const robotFileDecompressInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
@@ -50,7 +33,6 @@ This Robot supports the following archive formats:
 - 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
@@ -68,9 +50,12 @@ This <dfn>Robot</dfn> also detects and handles any of the following before evalu
 - 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>.
+For security reasons, archives containing symlinks that point outside the archived directory will cause the <dfn>Assembly</dfn> to fail.
 
 Password-protected archives (ZIP with ZipCrypto or AES encryption, RAR encrypted, 7z with AES-256) are supported via the \`password\` parameter.
+`),
+    ignore_errors: robotBase.shape.ignore_errors.describe(`${robotParameterDocs.ignore_errors.description}
+Metadata extraction can fail for files inside an archive, for example when an archived file has a size of zero bytes. Configure the \`"meta"\` phase when decompression should continue in that case.
 `),
     password: z
         .string()
@@ -83,17 +68,6 @@ Supports encrypted ZIP (ZipCrypto and AES), RAR (encrypted), and 7z (AES-256 enc
 For security, this value should be passed via Template Variables (\`\${fields.archive_password}\`) or Template Credentials rather than hardcoded in your Assembly Instructions. The password is never logged or included in Assembly status responses.
 
 If the archive is encrypted and no password is provided, or if the password is incorrect, the <dfn>Assembly</dfn> will fail with a \`FILE_DECOMPRESS_PASSWORD_REQUIRED\` or \`FILE_DECOMPRESS_PASSWORD_INCORRECT\` error.
-`),
-    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.
 `),
     turbo: z
         .boolean()
@@ -109,10 +83,5 @@ Turbo Mode also changes usage accounting: emitted extracted-file bytes and origi
 `),
 })
     .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);
+export const robotDefinition = defineRobot(meta, robotFileDecompressInstructionsSchema);
+export const { withHiddenFields: robotFileDecompressInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFileDecompressInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema, } = robotDefinition;

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

@@ -1,11 +1,12 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export type { FilterCondition, FilterConditionOperator, FilterConditionPart, } from './_instructions-primitives.ts';
 export { filterConditionOperatorSchema, filterConditionPartSchema, } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -67,14 +68,14 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
     error_on_decline: z.ZodDefault<z.ZodBoolean>;
     error_msg: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/file/filter";
     result: boolean;
+    robot: "/file/filter";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    condition_type: "or" | "and";
     error_on_decline: boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    condition_type: "or" | "and";
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -89,13 +90,14 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
-    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
-    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
 }, {
     robot: "/file/filter";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -110,20 +112,23 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
-    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
-    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
-    condition_type?: "or" | "and" | undefined;
     error_on_decline?: boolean | undefined;
     error_msg?: string | undefined;
+    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    condition_type?: "or" | "and" | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotFileFilterInstructionsSchema.shape>;
 export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
@@ -185,12 +190,13 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/filter";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    condition_type: "or" | "and";
     error_on_decline: boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    condition_type: "or" | "and";
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -205,14 +211,14 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
-    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
-    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
 }, {
     robot: "/file/filter";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -227,22 +233,21 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
-    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
-    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "<" | "=" | ">" | "empty" | "==" | "===" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
-    condition_type?: "or" | "and" | undefined;
     error_on_decline?: boolean | undefined;
     error_msg?: string | undefined;
-}>;
-export type RobotFileFilterInstructions = z.infer<typeof robotFileFilterInstructionsSchema>;
-export type RobotFileFilterInstructionsWithHiddenFields = z.infer<typeof robotFileFilterInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    declines?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    accepts?: string | [string | number | (string | number | null)[] | null, "includes" | "regex" | "empty" | "=" | "==" | "===" | "<" | ">" | "<=" | ">=" | "!=" | "!==" | "!regex" | "!includes" | "!empty", string | number | (string | number | null)[] | null][] | null | undefined;
+    condition_type?: "or" | "and" | undefined;
+}>, interpolatableRobotFileFilterInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -302,14 +307,14 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
     error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     error_msg: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/file/filter";
     result: string | boolean;
+    robot: "/file/filter";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
-    condition_type: string;
     error_on_decline: string | boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    condition_type: string;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -324,13 +329,14 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
-    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
     declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
+    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
 }, {
     robot: "/file/filter";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -345,22 +351,21 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
-    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
-    declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
-    condition_type?: string | undefined;
     error_on_decline?: string | boolean | undefined;
     error_msg?: string | undefined;
-}>;
-export type InterpolatableRobotFileFilterInstructions = InterpolatableRobotFileFilterInstructionsInput;
-export type InterpolatableRobotFileFilterInstructionsInput = z.input<typeof interpolatableRobotFileFilterInstructionsSchema>;
-export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
+    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
+    condition_type?: string | undefined;
+}>, interpolatableRobotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
@@ -421,12 +426,13 @@ export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSc
     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, {
     robot: "/file/filter";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
-    condition_type: string;
     error_on_decline: string | boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    condition_type: string;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -441,14 +447,14 @@ export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSc
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
-    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
     declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
+    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
 }, {
     robot: "/file/filter";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -463,17 +469,23 @@ export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSc
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
-    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
-    declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
-    condition_type?: string | undefined;
     error_on_decline?: string | boolean | undefined;
     error_msg?: string | undefined;
+    declines?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
+    accepts?: string | (string | [string | number | (string | number | null)[] | null, string, string | number | (string | number | null)[] | null])[] | null | undefined;
+    condition_type?: string | undefined;
 }>;
-export type InterpolatableRobotFileFilterInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileFilterInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileFilterInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileFilterInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotFileFilterInstructions = Instructions['output'];
+export type RobotFileFilterInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFileFilterInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileFilterInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileFilterInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFileFilterInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
 //# sourceMappingURL=file-filter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"file-filter.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,YAAY,EACV,eAAe,EACf,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,GAC1B,MAAM,+BAA+B,CAAA;AAEtC,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,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"}
+{"version":3,"file":"file-filter.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAY1B,YAAY,EACV,eAAe,EACf,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,GAC1B,MAAM,+BAA+B,CAAA;AAEtC,eAAO,MAAM,IAAI,EAAE,cAkBlB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6GnC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,iCAAiC,CAAC,KAAK,CACtC,CAAA;AAEtD,eAAO,MACa,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACnD,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC/B,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC9E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,2BAA2B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAChE,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACtF,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC3F,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAChG,MAAM,MAAM,yDAAyD,GACnE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,8DAA8D,GACxE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v3/robots/file-filter.js

@@ -1,44 +1,24 @@
 import { z } from 'zod/v3';
-import { filterCondition, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobot, filterCondition, robotBase, robotFileFilteringMeta, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
 export { filterConditionOperatorSchema, filterConditionPartSchema, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 0,
-    discount_factor: 0,
-    discount_pct: 100,
-    example_code: {
-        steps: {
-            filtered: {
-                robot: '/file/filter',
-                use: ':original',
-                declines: [['${file.size}', '>', '20mb']],
-                error_on_decline: true,
-                error_msg: 'File size must not exceed 20 MB',
-            },
-        },
-    },
+    ...robotFileFilteringMeta,
+    example_code: createProcessingExample('filtered', '/file/filter', {
+        declines: [['${file.size}', '>', '20mb']],
+        error_on_decline: true,
+        error_msg: 'File size must not exceed 20 MB',
+    }),
     example_code_description: 'Reject files that are larger than 20 MB:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Filtering',
     purpose_sentence: 'directs files to different encoding Steps based on your conditions',
     purpose_verb: 'filter',
     purpose_word: 'filter',
     purpose_words: 'Filter files',
-    service_slug: 'file-filtering',
-    slot_count: 0,
     title: 'Filter files',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'FileFilterRobot',
     priceFactor: 100,
     queueSlotCount: 0,
     downloadInputFiles: false,
     preserveInputFileUrls: true,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotFileFilterInstructionsSchema = robotBase
     .merge(robotUse)
@@ -139,21 +119,12 @@ Specifies the condition type according to which the members of the \`accepts\` o
     error_on_decline: z
         .boolean()
         .default(false)
-        .describe(`
-If this is set to \`true\` and one or more files are declined, the Assembly will be stopped and marked with an error.
-`),
+        .describe(robotParameterDocs.error_on_decline.description),
     error_msg: z
         .string()
         .default('One of your files was declined')
-        .describe(`
-The error message shown to your users (such as by Uppy) when a file is declined and \`error_on_decline\` is set to \`true\`.
-`),
+        .describe(robotParameterDocs.error_msg.description),
 })
     .strict();
-export const robotFileFilterInstructionsWithHiddenFieldsSchema = robotFileFilterInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotFileFilterInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotFileFilterInstructionsSchema = interpolateRobot(robotFileFilterInstructionsSchema);
-export const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileFilterInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotFileFilterInstructionsSchema);
+export const { withHiddenFields: robotFileFilterInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFileFilterInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFileFilterInstructionsWithHiddenFieldsSchema, } = robotDefinition;