transloadit 4.14.0 → 5.0.0

package/dist/alphalib/types/robots/file-virusscan.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod';
 export declare const meta: RobotMetaInput;
 export declare const robotFileVirusscanInstructionsSchema: 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">]>>;
+    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>;
@@ -15,12 +16,12 @@ export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<{
         as: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }>, "many">]>, z.ZodObject<{
         steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -28,12 +29,12 @@ export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<{
             as: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }>, "many">]>;
         bundle_steps: z.ZodOptional<z.ZodBoolean>;
         group_by_original: z.ZodOptional<z.ZodBoolean>;
@@ -41,8 +42,8 @@ export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<{
     }, "strict", z.ZodTypeAny, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -50,8 +51,8 @@ export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<{
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -62,57 +63,64 @@ export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<{
     error_on_decline: z.ZodDefault<z.ZodBoolean>;
     error_msg: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
+    user_meta: Record<string, unknown>;
     robot: "/file/virusscan";
     result: boolean;
     force_accept: boolean;
     ignore_errors: string[];
     error_on_decline: boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         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;
 }, {
     robot: "/file/virusscan";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
-    queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     error_on_decline?: boolean | undefined;
     error_msg?: string | undefined;
 }>;
+declare const hiddenFields: {
+    can_use_daemon_fallback: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotFileVirusscanInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotFileVirusscanInstructionsWithHiddenFieldsSchema: 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">]>>;
+    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")[]>>;
@@ -122,12 +130,12 @@ export declare const robotFileVirusscanInstructionsWithHiddenFieldsSchema: z.Zod
         as: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }>, "many">]>, z.ZodObject<{
         steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -135,12 +143,12 @@ export declare const robotFileVirusscanInstructionsWithHiddenFieldsSchema: z.Zod
             as: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }>, "many">]>;
         bundle_steps: z.ZodOptional<z.ZodBoolean>;
         group_by_original: z.ZodOptional<z.ZodBoolean>;
@@ -148,8 +156,8 @@ export declare const robotFileVirusscanInstructionsWithHiddenFieldsSchema: z.Zod
     }, "strict", z.ZodTypeAny, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -157,8 +165,8 @@ export declare const robotFileVirusscanInstructionsWithHiddenFieldsSchema: z.Zod
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -171,61 +179,61 @@ export declare const robotFileVirusscanInstructionsWithHiddenFieldsSchema: z.Zod
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
     can_use_daemon_fallback: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
+    user_meta: Record<string, unknown>;
     robot: "/file/virusscan";
     force_accept: boolean;
     ignore_errors: string[];
     error_on_decline: boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         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;
     can_use_daemon_fallback?: boolean | undefined;
 }, {
     robot: "/file/virusscan";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    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;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     error_on_decline?: boolean | undefined;
     error_msg?: string | undefined;
     can_use_daemon_fallback?: boolean | undefined;
-}>;
-export type RobotFileVirusscanInstructions = z.infer<typeof robotFileVirusscanInstructionsSchema>;
-export type RobotFileVirusscanInstructionsWithHiddenFields = z.infer<typeof robotFileVirusscanInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodObject<{
+}>, interpolatableRobotFileVirusscanInstructionsSchema: 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">]>]>>;
+    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]>>;
@@ -236,12 +244,12 @@ export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodOb
         as: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }>, "many">]>, z.ZodObject<{
         steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -249,12 +257,12 @@ export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodOb
             as: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }>, "many">]>;
         bundle_steps: z.ZodOptional<z.ZodBoolean>;
         group_by_original: z.ZodOptional<z.ZodBoolean>;
@@ -262,8 +270,8 @@ export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodOb
     }, "strict", z.ZodTypeAny, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -271,8 +279,8 @@ export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodOb
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -282,59 +290,59 @@ export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodOb
     error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     error_msg: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
+    user_meta: Record<string, unknown>;
     robot: "/file/virusscan";
     result: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     error_on_decline: string | boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    queue?: string | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         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;
 }, {
     robot: "/file/virusscan";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    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;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     error_on_decline?: string | boolean | undefined;
     error_msg?: string | undefined;
-}>;
-export type InterpolatableRobotFileVirusscanInstructions = InterpolatableRobotFileVirusscanInstructionsInput;
-export type InterpolatableRobotFileVirusscanInstructionsInput = z.input<typeof interpolatableRobotFileVirusscanInstructionsSchema>;
-export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}>, interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema: 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">]>]>>;
+    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")[]>]>>;
@@ -344,12 +352,12 @@ export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenField
         as: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }, {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }>, "many">]>, z.ZodObject<{
         steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -357,12 +365,12 @@ export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenField
             as: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }, {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }>, "many">]>;
         bundle_steps: z.ZodOptional<z.ZodBoolean>;
         group_by_original: z.ZodOptional<z.ZodBoolean>;
@@ -370,8 +378,8 @@ export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenField
     }, "strict", z.ZodTypeAny, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -379,8 +387,8 @@ export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenField
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -392,56 +400,64 @@ export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenField
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
     can_use_daemon_fallback: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }, "strict", z.ZodTypeAny, {
+    user_meta: Record<string, unknown>;
     robot: "/file/virusscan";
     force_accept: string | boolean;
     ignore_errors: string | string[];
     error_on_decline: string | boolean;
     error_msg: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    queue?: string | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         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;
     can_use_daemon_fallback?: string | boolean | undefined;
 }, {
     robot: "/file/virusscan";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
     use?: string | string[] | {
         name: string;
-        fields?: string | undefined;
         as?: string | undefined;
+        fields?: string | undefined;
     }[] | {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    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;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     error_on_decline?: string | boolean | undefined;
     error_msg?: string | undefined;
     can_use_daemon_fallback?: string | boolean | undefined;
 }>;
-export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotFileVirusscanInstructions = Instructions['output'];
+export type RobotFileVirusscanInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFileVirusscanInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileVirusscanInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFileVirusscanInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=file-virusscan.d.ts.map

package/dist/alphalib/types/robots/file-virusscan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-virusscan.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-virusscan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,IAAI,EAAE,cA8ClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"file-virusscan.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-virusscan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,IAAI,EAAE,cA2BlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBtC,CAAA;AAEX,QAAA,MAAM,YAAY;;CAOjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,oCAAoC,CAAC,KAAK,EACjD,OAAO,YAAY,CACoE,CAAA;AAEzF,eAAO,MACa,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACtD,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEhE,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACnD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,8BAA8B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACnE,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,iDAAiD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACnG,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,iEAAiE,GAC3E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/alphalib/types/robots/file-virusscan.js

@@ -1,53 +1,34 @@
 import { z } from 'zod';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobotWithHiddenFields, robotBase, robotFileFilteringMeta, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    description: 'While 100% security is a myth, having /file/virusscan as a gatekeeper bot helps reject millions of trojans, viruses, malware & other malicious threats before they reach your platform.',
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            scanned: {
-                robot: '/file/virusscan',
-                use: ':original',
-                error_on_decline: true,
-                error_msg: 'At least one of the uploaded files is malicious and was declined',
-            },
-        },
-    },
+    ...robotFileFilteringMeta,
+    description: 'While 100% security is a myth, having /file/virusscan as a gatekeeper bot helps reject millions of trojans, viruses, malware & other malicious threats before they reach your platform.',
+    example_code: createProcessingExample('scanned', '/file/virusscan', {
+        error_on_decline: true,
+        error_msg: 'At least one of the uploaded files is malicious and was declined',
+    }),
     example_code_description: 'Scan uploaded files and throw an error if a malicious file is detected:',
-    minimum_charge: 1048576,
     ogimage: '/assets/images/robots/ogimages/file-virusscan.jpg',
-    output_factor: 1,
-    override_lvl1: 'File Filtering',
-    purpose_sentence: 'rejects millions of trojans, viruses, malware & other malicious threats before they reach your platform',
+    purpose_sentence: 'rejects millions of trojans, viruses, malware & other malicious threats before they reach your platform',
     purpose_verb: 'scan',
     purpose_word: 'scan for viruses and reject malware',
     purpose_words: 'Scan files for viruses',
-    service_slug: 'file-filtering',
-    slot_count: 16,
     title: 'Scan files for viruses',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'FileVirusscanRobot',
-    priceFactor: 1,
     queueSlotCount: 16,
+    preserveInputFileUrls: true,
     minimumCharge: 1048576,
     lazyLoad: true,
     installVersionFile: typeof process !== 'undefined' && process.env.API2_CLAMD_INSTALL_VERSION_FILE
         ? process.env.API2_CLAMD_INSTALL_VERSION_FILE
         : '',
     isAllowedForUrlTransform: false,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotFileVirusscanInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/file/virusscan').describe(`
-      This <dfn>Robot</dfn> is built on top of [ClamAV](https://www.clamav.net/), the best open source antivirus engine available. We update its signatures on a daily basis.
+This <dfn>Robot</dfn> is built on top of [ClamAV](https://www.clamav.net/), the best open source antivirus engine available. We update its signatures on a daily basis.
 
 By default, this <dfn>Robot</dfn> excludes all malicious files from further processing without any additional notification. This behavior can be changed by setting \`error_on_decline\` to \`true\`, which will stop <dfn>Assemblies</dfn> as soon as malicious files are found. Such <dfn>Assemblies</dfn> will then be marked with an error.
 
@@ -56,28 +37,21 @@ We allow the use of industry standard [EICAR files](https://www.eicar.org/downlo
     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 robotFileVirusscanInstructionsWithHiddenFieldsSchema = robotFileVirusscanInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotFileVirusscanInstructionsSchema.shape.result])
-        .optional(),
+const hiddenFields = {
     can_use_daemon_fallback: z
         .boolean()
         .optional()
         .describe(`
 Allow the robot to use a daemon fallback mechanism if the primary scanning method fails.
 `),
-});
-export const interpolatableRobotFileVirusscanInstructionsSchema = interpolateRobot(robotFileVirusscanInstructionsSchema);
-export const interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileVirusscanInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotFileVirusscanInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotFileVirusscanInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFileVirusscanInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema, } = robotDefinition;
 //# sourceMappingURL=file-virusscan.js.map

package/dist/alphalib/types/robots/file-virusscan.js.map

@@ -1 +1 @@
-{"version":3,"file":"file-virusscan.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-virusscan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAErF,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,UAAU,EAAE,CAAC;IACb,WAAW,EACT,6LAA6L;IAC/L,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,OAAO,EAAE;gBACP,KAAK,EAAE,iBAAiB;gBACxB,GAAG,EAAE,WAAW;gBAChB,gBAAgB,EAAE,IAAI;gBACtB,SAAS,EAAE,kEAAkE;aAC9E;SACF;KACF;IACD,wBAAwB,EACtB,yEAAyE;IAC3E,cAAc,EAAE,OAAO;IACvB,OAAO,EAAE,mDAAmD;IAC5D,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EACd,6GAA6G;IAC/G,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,qCAAqC;IACnD,aAAa,EAAE,wBAAwB;IACvC,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,wBAAwB;IAC/B,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;IACzB,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,CAAC;IACd,cAAc,EAAE,EAAE;IAClB,aAAa,EAAE,OAAO;IACtB,QAAQ,EAAE,IAAI;IACd,kBAAkB,EAChB,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,+BAA+B;QAC3E,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,+BAA+B;QAC7C,CAAC,CAAC,EAAE;IACR,wBAAwB,EAAE,KAAK;IAC/B,mBAAmB,EAAE,IAAI;IACzB,UAAU,EAAE,KAAK;IACjB,iDAAiD,EAAE,KAAK;IACxD,KAAK,EAAE,IAAI;CACZ,CAAA;AAED,MAAM,CAAC,MAAM,oCAAoC,GAAG,SAAS;KAC1D,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC;;;;;;CAMhD,CAAC;IACE,gBAAgB,EAAE,CAAC;SAChB,OAAO,EAAE;SACT,OAAO,CAAC,KAAK,CAAC;SACd,QAAQ,CAAC;;CAEf,CAAC;IACE,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,OAAO,CAAC,gCAAgC,CAAC;SACzC,QAAQ,CAAC;;CAEf,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,oDAAoD,GAC/D,oCAAoC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC;SACN,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,oCAAoC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC9E,QAAQ,EAAE;IACb,uBAAuB,EAAE,CAAC;SACvB,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CAAC;;CAEf,CAAC;CACC,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,kDAAkD,GAAG,gBAAgB,CAChF,oCAAoC,CACrC,CAAA;AAQD,MAAM,CAAC,MAAM,kEAAkE,GAAG,gBAAgB,CAChG,oDAAoD,CACrD,CAAA"}
+{"version":3,"file":"file-virusscan.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-virusscan.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EACL,uBAAuB,EACvB,2BAA2B,EAC3B,SAAS,EACT,sBAAsB,EACtB,kBAAkB,EAClB,QAAQ,GACT,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,GAAG,sBAAsB;IACzB,WAAW,EACT,yLAAyL;IAC3L,YAAY,EAAE,uBAAuB,CAAC,SAAS,EAAE,iBAAiB,EAAE;QAClE,gBAAgB,EAAE,IAAI;QACtB,SAAS,EAAE,kEAAkE;KAC9E,CAAC;IACF,wBAAwB,EACtB,yEAAyE;IAC3E,OAAO,EAAE,mDAAmD;IAC5D,gBAAgB,EACd,yGAAyG;IAC3G,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,qCAAqC;IACnD,aAAa,EAAE,wBAAwB;IACvC,KAAK,EAAE,wBAAwB;IAC/B,IAAI,EAAE,oBAAoB;IAC1B,cAAc,EAAE,EAAE;IAClB,qBAAqB,EAAE,IAAI;IAC3B,aAAa,EAAE,OAAO;IACtB,QAAQ,EAAE,IAAI;IACd,kBAAkB,EAChB,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,+BAA+B;QAC3E,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,+BAA+B;QAC7C,CAAC,CAAC,EAAE;IACR,wBAAwB,EAAE,KAAK;CAChC,CAAA;AAED,MAAM,CAAC,MAAM,oCAAoC,GAAG,SAAS;KAC1D,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC;;;;;;CAMhD,CAAC;IACE,gBAAgB,EAAE,CAAC;SAChB,OAAO,EAAE;SACT,OAAO,CAAC,KAAK,CAAC;SACd,QAAQ,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,WAAW,CAAC;IAC5D,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,OAAO,CAAC,gCAAgC,CAAC;SACzC,QAAQ,CAAC,kBAAkB,CAAC,SAAS,CAAC,WAAW,CAAC;CACtD,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,YAAY,GAAG;IACnB,uBAAuB,EAAE,CAAC;SACvB,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CAAC;;CAEb,CAAC;CACD,CAAA;AAED,MAAM,CAAC,MAAM,eAAe,GAGxB,2BAA2B,CAAC,IAAI,EAAE,oCAAoC,EAAE,YAAY,CAAC,CAAA;AAEzF,MAAM,CAAC,MAAM,EACX,gBAAgB,EAAE,oDAAoD,EACtE,cAAc,EAAE,kDAAkD,EAClE,8BAA8B,EAC5B,kEAAkE,GACrE,GAAG,eAAe,CAAA"}