@transloadit/zod 4.3.1 → 4.3.3

package/dist/v3/robots/edgly-deliver.d.ts

@@ -1,7 +1,8 @@
-import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotEdglyDeliverInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -14,10 +15,12 @@ export declare const robotEdglyDeliverInstructionsSchema: z.ZodObject<{
     result: boolean;
     force_accept: boolean;
     ignore_errors: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
 }, {
     robot: "/edgly/deliver";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
     queue?: "batch" | undefined;
@@ -25,6 +28,7 @@ export declare const robotEdglyDeliverInstructionsSchema: z.ZodObject<{
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
 }>;
 export declare const robotEdglyDeliverInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -36,11 +40,13 @@ export declare const robotEdglyDeliverInstructionsWithHiddenFieldsSchema: z.ZodO
     robot: "/edgly/deliver";
     force_accept: boolean;
     ignore_errors: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
 }, {
     robot: "/edgly/deliver";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
@@ -50,6 +56,7 @@ export declare const robotEdglyDeliverInstructionsWithHiddenFieldsSchema: z.ZodO
 export type RobotEdglyDeliverInstructions = z.infer<typeof robotEdglyDeliverInstructionsSchema>;
 export type RobotEdglyDeliverInstructionsWithHiddenFields = z.infer<typeof robotEdglyDeliverInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotEdglyDeliverInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -61,10 +68,12 @@ export declare const interpolatableRobotEdglyDeliverInstructionsSchema: z.ZodObj
     result: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
 }, {
     robot: "/edgly/deliver";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
@@ -74,6 +83,7 @@ export declare const interpolatableRobotEdglyDeliverInstructionsSchema: z.ZodObj
 export type InterpolatableRobotEdglyDeliverInstructions = InterpolatableRobotEdglyDeliverInstructionsInput;
 export type InterpolatableRobotEdglyDeliverInstructionsInput = z.input<typeof interpolatableRobotEdglyDeliverInstructionsSchema>;
 export declare const interpolatableRobotEdglyDeliverInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -84,11 +94,13 @@ export declare const interpolatableRobotEdglyDeliverInstructionsWithHiddenFields
     robot: "/edgly/deliver";
     force_accept: string | boolean;
     ignore_errors: string | string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
 }, {
     robot: "/edgly/deliver";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;

package/dist/v3/robots/edgly-deliver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edgly-deliver.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/edgly-deliver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;EAMrC,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"}
+{"version":3,"file":"edgly-deliver.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/edgly-deliver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;EAMrC,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.d.ts

@@ -1,7 +1,8 @@
-import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotFileCompressInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -76,6 +77,7 @@ export declare const robotFileCompressInstructionsSchema: z.ZodObject<{
     compression_level: number;
     file_layout: "advanced" | "simple" | "relative-path";
     path?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -96,6 +98,7 @@ export declare const robotFileCompressInstructionsSchema: z.ZodObject<{
 }, {
     robot: "/file/compress";
     path?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -123,6 +126,7 @@ export declare const robotFileCompressInstructionsSchema: z.ZodObject<{
     archive_name?: string | undefined;
 }>;
 export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -195,6 +199,7 @@ export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: z.ZodO
     compression_level: number;
     file_layout: "advanced" | "simple" | "relative-path";
     path?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -216,6 +221,7 @@ export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: z.ZodO
 }, {
     robot: "/file/compress";
     path?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -245,6 +251,7 @@ export declare const robotFileCompressInstructionsWithHiddenFieldsSchema: z.ZodO
 export type RobotFileCompressInstructions = z.infer<typeof robotFileCompressInstructionsSchema>;
 export type RobotFileCompressInstructionsWithHiddenFields = z.infer<typeof robotFileCompressInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotFileCompressInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -317,6 +324,7 @@ export declare const interpolatableRobotFileCompressInstructionsSchema: z.ZodObj
     compression_level: string | number;
     file_layout: string;
     path?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -337,6 +345,7 @@ export declare const interpolatableRobotFileCompressInstructionsSchema: z.ZodObj
 }, {
     robot: "/file/compress";
     path?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -366,6 +375,7 @@ export declare const interpolatableRobotFileCompressInstructionsSchema: z.ZodObj
 export type InterpolatableRobotFileCompressInstructions = InterpolatableRobotFileCompressInstructionsInput;
 export type InterpolatableRobotFileCompressInstructionsInput = z.input<typeof interpolatableRobotFileCompressInstructionsSchema>;
 export declare const interpolatableRobotFileCompressInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -437,6 +447,7 @@ export declare const interpolatableRobotFileCompressInstructionsWithHiddenFields
     compression_level: string | number;
     file_layout: string;
     path?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -458,6 +469,7 @@ export declare const interpolatableRobotFileCompressInstructionsWithHiddenFields
 }, {
     robot: "/file/compress";
     path?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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

@@ -1 +1 @@
-{"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,cAyElB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DrC,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"}
+{"version":3,"file":"file-compress.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-compress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAyElB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DrC,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-decompress.d.ts

@@ -1,7 +1,8 @@
-import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotFileDecompressInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -65,6 +66,7 @@ export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
     force_accept: boolean;
     ignore_errors: ("meta" | "execute")[];
     turbo: boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -84,6 +86,7 @@ export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
     password?: string | undefined;
 }, {
     robot: "/file/decompress";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -107,6 +110,7 @@ export declare const robotFileDecompressInstructionsSchema: z.ZodObject<{
     turbo?: boolean | undefined;
 }>;
 export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -169,6 +173,7 @@ export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.Zo
     force_accept: boolean;
     ignore_errors: ("meta" | "execute")[];
     turbo: boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -189,6 +194,7 @@ export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.Zo
     password?: string | undefined;
 }, {
     robot: "/file/decompress";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -214,6 +220,7 @@ export declare const robotFileDecompressInstructionsWithHiddenFieldsSchema: z.Zo
 export type RobotFileDecompressInstructions = z.infer<typeof robotFileDecompressInstructionsSchema>;
 export type RobotFileDecompressInstructionsWithHiddenFields = z.infer<typeof robotFileDecompressInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotFileDecompressInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -276,6 +283,7 @@ export declare const interpolatableRobotFileDecompressInstructionsSchema: z.ZodO
     force_accept: string | boolean;
     ignore_errors: string | ("meta" | "execute")[];
     turbo: string | boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -295,6 +303,7 @@ export declare const interpolatableRobotFileDecompressInstructionsSchema: z.ZodO
     password?: string | undefined;
 }, {
     robot: "/file/decompress";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -320,6 +329,7 @@ export declare const interpolatableRobotFileDecompressInstructionsSchema: z.ZodO
 export type InterpolatableRobotFileDecompressInstructions = InterpolatableRobotFileDecompressInstructionsInput;
 export type InterpolatableRobotFileDecompressInstructionsInput = z.input<typeof interpolatableRobotFileDecompressInstructionsSchema>;
 export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -381,6 +391,7 @@ export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFiel
     force_accept: string | boolean;
     ignore_errors: string | ("meta" | "execute")[];
     turbo: string | boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -401,6 +412,7 @@ export declare const interpolatableRobotFileDecompressInstructionsWithHiddenFiel
     password?: string | undefined;
 }, {
     robot: "/file/decompress";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"file-decompress.d.ts","sourceRoot":"","sources":["../../../src/v3/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,cAkClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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"}
+{"version":3,"file":"file-decompress.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-decompress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAkClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/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/v3/robots/file-filter.d.ts

@@ -1,7 +1,8 @@
-import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v3';
 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">>]>>;
     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"]>>;
@@ -71,6 +72,7 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
     condition_type: "or" | "and";
     error_on_decline: boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -91,6 +93,7 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
     declines?: 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;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -117,6 +120,7 @@ export declare const robotFileFilterInstructionsSchema: z.ZodObject<{
     error_msg?: string | undefined;
 }>;
 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">>]>>;
     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>;
@@ -184,6 +188,7 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
     condition_type: "or" | "and";
     error_on_decline: boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -205,6 +210,7 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
     declines?: 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;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -233,6 +239,7 @@ export declare const robotFileFilterInstructionsWithHiddenFieldsSchema: z.ZodObj
 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">>]>>;
     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"]>]>>;
@@ -300,6 +307,7 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
     condition_type: string;
     error_on_decline: string | boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -320,6 +328,7 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
     declines?: 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;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -348,6 +357,7 @@ export declare const interpolatableRobotFileFilterInstructionsSchema: z.ZodObjec
 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">>]>>;
     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]>>;
@@ -414,6 +424,7 @@ export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSc
     condition_type: string;
     error_on_decline: string | boolean;
     error_msg: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -435,6 +446,7 @@ export declare const interpolatableRobotFileFilterInstructionsWithHiddenFieldsSc
     declines?: 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;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6GnC,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,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,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"}

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

@@ -50,6 +50,10 @@ The <dfn>Robot</dfn> has two modes of operation:
 - Constructing conditions out of arrays with 3 members each. For example, \`["\${file.size}", "<=", "720"]\`
 - Writing conditions in JavaScript. For example, \`\${file.size <= 720}\`. See also [Dynamic Evaluation](/docs/topics/dynamic-evaluation/).
 
+If you want a \`/file/filter\` Step to pass every input file through unchanged, leave \`accepts\` and
+\`declines\` unset, or set them to \`null\`. Do not use \`"accepts": "true"\` for this: plain strings
+are treated as JavaScript expressions only when they use the \`\${...}\` form, such as \`"\${true}"\`.
+
 Passing JavaScript allows you to implement logic as complex as you wish, however it’s slower than combining arrays of conditions, and will be charged for per invocation via [🤖/script/run](/docs/robots/script-run/).
 
 ### Conditions as arrays
@@ -99,7 +103,7 @@ As indicated, we charge for this via [🤖/script/run](/docs/robots/script-run/)
 `),
     accepts: filterCondition
         .describe(`
-Files that match at least one requirement will be accepted, or declined otherwise. If the value is \`null\`, all files will be accepted. If the array is empty, no files will be accepted. Examples:
+Files that match at least one requirement will be accepted, or declined otherwise. If the value is \`null\`, all files will be accepted. If the array is empty, no files will be accepted. Omit this parameter or set it to \`null\` when you want the Step to pass every file through. Examples:
 
 \`[["\${file.mime}", "==", "image/gif"]]\`
 \`[["\${file.size}", "<", "5kb"]]\`

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

@@ -1,7 +1,8 @@
-import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotFileHashInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -69,6 +70,7 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
     ignore_errors: string[];
     algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
     partial_size: number;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -88,6 +90,7 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
 }, {
     robot: "/file/hash";
     partial?: "full" | "last" | "first" | "both" | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -111,6 +114,7 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
     partial_size?: number | undefined;
 }>;
 export declare const robotFileHashInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -176,6 +180,7 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     ignore_errors: string[];
     algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
     partial_size: number;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -196,6 +201,7 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
 }, {
     robot: "/file/hash";
     partial?: "full" | "last" | "first" | "both" | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -221,6 +227,7 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
 export type RobotFileHashInstructions = z.infer<typeof robotFileHashInstructionsSchema>;
 export type RobotFileHashInstructionsWithHiddenFields = z.infer<typeof robotFileHashInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotFileHashInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -286,6 +293,7 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     ignore_errors: string | string[];
     algorithm: string;
     partial_size: string | number;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -305,6 +313,7 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
 }, {
     robot: "/file/hash";
     partial?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -330,6 +339,7 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
 export type InterpolatableRobotFileHashInstructions = InterpolatableRobotFileHashInstructionsInput;
 export type InterpolatableRobotFileHashInstructionsInput = z.input<typeof interpolatableRobotFileHashInstructionsSchema>;
 export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -394,6 +404,7 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     ignore_errors: string | string[];
     algorithm: string;
     partial_size: string | number;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -414,6 +425,7 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
 }, {
     robot: "/file/hash";
     partial?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-hash.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,cAiClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}
+{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAiClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}