@transloadit/zod 4.5.0 → 5.0.0

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotFileVerifyInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -39,15 +40,17 @@ export declare const robotFileVerifyInstructionsSchema: z.ZodObject<{
     repair_pdf: z.ZodDefault<z.ZodBoolean>;
     verify_to_be: z.ZodDefault<z.ZodString>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotFileVerifyInstructionsSchema.shape>;
 export declare const robotFileVerifyInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -76,24 +79,22 @@ export declare const robotFileVerifyInstructionsWithHiddenFieldsSchema: z.ZodObj
     repair_pdf: z.ZodDefault<z.ZodBoolean>;
     verify_to_be: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotFileVerifyInstructions = z.infer<typeof robotFileVerifyInstructionsSchema>;
-export type RobotFileVerifyInstructionsWithHiddenFields = z.infer<typeof robotFileVerifyInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileVerifyInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotFileVerifyInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -112,27 +113,25 @@ export declare const interpolatableRobotFileVerifyInstructionsSchema: z.ZodObjec
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/file/verify">;
-    error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    error_msg: z.ZodDefault<z.ZodString>;
-    repair_pdf: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    verify_to_be: z.ZodDefault<z.ZodString>;
-}, z.core.$strict>;
-export type InterpolatableRobotFileVerifyInstructions = InterpolatableRobotFileVerifyInstructionsInput;
-export type InterpolatableRobotFileVerifyInstructionsInput = z.input<typeof interpolatableRobotFileVerifyInstructionsSchema>;
-export declare const interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    error_on_decline: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    error_msg: z.ZodPrefault<z.ZodString>;
+    repair_pdf: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    verify_to_be: z.ZodPrefault<z.ZodString>;
+}, z.core.$strict>, interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -151,12 +150,18 @@ export declare const interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSc
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/file/verify">;
-    error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    error_msg: z.ZodDefault<z.ZodString>;
-    repair_pdf: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    verify_to_be: z.ZodDefault<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    error_on_decline: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    error_msg: z.ZodPrefault<z.ZodString>;
+    repair_pdf: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    verify_to_be: z.ZodPrefault<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotFileVerifyInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileVerifyInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotFileVerifyInstructions = Instructions['output'];
+export type RobotFileVerifyInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFileVerifyInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileVerifyInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileVerifyInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFileVerifyInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=file-verify.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"file-verify.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/file-verify.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,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6BnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,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-verify.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/file-verify.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;AAW1B,eAAO,MAAM,IAAI,EAAE,cAiBlB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyBnC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,iCAAiC,CAAC,KAAK,CACtC,CAAA;AAEtD,eAAO,MACa,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACnD,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC/B,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC9E,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/v4/robots/file-verify.js

@@ -1,42 +1,21 @@
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobot, robotBase, robotFileFilteringMeta, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 4,
+    ...robotFileFilteringMeta,
     description: '/file/verify is a simple Robot that helps ensure that the files you upload are of the type you initially intended. This is especially useful when handling user-generated content, where you may not want to run certain Steps in your Template if the user hasn’t uploaded a file of the correct type. Another use case for /file/verify is when a user uploads a ZIP file, but we find that it has a few damaged files inside when we extract it. Perhaps you don’t want to error out, but only send the good files to a next processing step. With /file/verify, you can do exactly that (assuming the default of `error_on_decline`: `true`).',
-    discount_factor: 0.25,
-    discount_pct: 75,
-    example_code: {
-        steps: {
-            scanned: {
-                robot: '/file/verify',
-                use: ':original',
-                error_on_decline: true,
-                error_msg: 'At least one of the uploaded files was not the desired type',
-                verify_to_be: 'image',
-            },
-        },
-    },
+    example_code: createProcessingExample('scanned', '/file/verify', {
+        error_on_decline: true,
+        error_msg: 'At least one of the uploaded files was not the desired type',
+        verify_to_be: 'image',
+    }),
     example_code_description: 'Scan the uploaded files and throw an error if they are not images:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Filtering',
     purpose_sentence: 'verifies your files are the type that you want',
     purpose_verb: 'verify',
     purpose_word: 'verify the file type',
     purpose_words: 'Verify the file type',
-    service_slug: 'file-filtering',
-    slot_count: 10,
     title: 'Verify the file type',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'FileVerifyRobot',
     priceFactor: 4,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotFileVerifyInstructionsSchema = robotBase
     .merge(robotUse)
@@ -45,15 +24,11 @@ export const robotFileVerifyInstructionsSchema = robotBase
     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),
     repair_pdf: z
         .boolean()
         .default(false)
@@ -68,10 +43,5 @@ The type that you want to match against to ensure your file is of this type. For
 `),
 })
     .strict();
-export const robotFileVerifyInstructionsWithHiddenFieldsSchema = robotFileVerifyInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotFileVerifyInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotFileVerifyInstructionsSchema = interpolateRobot(robotFileVerifyInstructionsSchema);
-export const interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileVerifyInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotFileVerifyInstructionsSchema);
+export const { withHiddenFields: robotFileVerifyInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFileVerifyInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFileVerifyInstructionsWithHiddenFieldsSchema, } = robotDefinition;

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -37,15 +38,20 @@ export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<{
     error_on_decline: z.ZodDefault<z.ZodBoolean>;
     error_msg: z.ZodDefault<z.ZodString>;
 }, z.core.$strict>;
+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<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -73,24 +79,22 @@ export declare const robotFileVirusscanInstructionsWithHiddenFieldsSchema: z.Zod
     error_msg: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
     can_use_daemon_fallback: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type RobotFileVirusscanInstructions = z.infer<typeof robotFileVirusscanInstructionsSchema>;
-export type RobotFileVirusscanInstructionsWithHiddenFields = z.infer<typeof robotFileVirusscanInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotFileVirusscanInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -109,25 +113,23 @@ export declare const interpolatableRobotFileVirusscanInstructionsSchema: z.ZodOb
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/file/virusscan">;
-    error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    error_msg: z.ZodDefault<z.ZodString>;
-}, z.core.$strict>;
-export type InterpolatableRobotFileVirusscanInstructions = InterpolatableRobotFileVirusscanInstructionsInput;
-export type InterpolatableRobotFileVirusscanInstructionsInput = z.input<typeof interpolatableRobotFileVirusscanInstructionsSchema>;
-export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    error_on_decline: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    error_msg: z.ZodPrefault<z.ZodString>;
+}, z.core.$strict>, interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -146,11 +148,17 @@ export declare const interpolatableRobotFileVirusscanInstructionsWithHiddenField
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/file/virusscan">;
-    error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    error_msg: z.ZodDefault<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    error_on_decline: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    error_msg: z.ZodPrefault<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
     can_use_daemon_fallback: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }, z.core.$strict>;
-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/v4/robots/file-virusscan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-virusscan.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/file-virusscan.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,cA8ClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAW7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,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/v4/robots/file-virusscan.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cA2BlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmBtC,CAAA;AAEX,QAAA,MAAM,YAAY;;CAMjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,oCAAoC,CAAC,KAAK,EACjD,OAAO,YAAY,CACoE,CAAA;AAEzF,eAAO,MACa,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACtD,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEhE,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACnD,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/v4/robots/file-virusscan.js

@@ -1,53 +1,35 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-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,27 +38,19 @@ 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(),
-    can_use_daemon_fallback: z
-        .boolean()
-        .optional()
+const hiddenFields = {
+    can_use_daemon_fallback: optionalWithV3Semantics(z
+        .boolean())
         .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;

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

@@ -1,15 +1,17 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
+import { createRobotSchemaVariants } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotFileWatermarkInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -36,15 +38,17 @@ export declare const robotFileWatermarkInstructionsSchema: z.ZodObject<{
     robot: z.ZodLiteral<"/file/watermark">;
     randomize: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
+declare const schemaVariants: ReturnType<typeof createRobotSchemaVariants<typeof robotFileWatermarkInstructionsSchema.shape>>;
 export declare const robotFileWatermarkInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -70,24 +74,22 @@ export declare const robotFileWatermarkInstructionsWithHiddenFieldsSchema: z.Zod
     robot: z.ZodLiteral<"/file/watermark">;
     randomize: z.ZodOptional<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotFileWatermarkInstructions = z.infer<typeof robotFileWatermarkInstructionsSchema>;
-export type RobotFileWatermarkInstructionsWithHiddenFields = z.infer<typeof robotFileWatermarkInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileWatermarkInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotFileWatermarkInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -107,23 +109,21 @@ export declare const interpolatableRobotFileWatermarkInstructionsSchema: z.ZodOb
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/file/watermark">;
     randomize: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotFileWatermarkInstructions = InterpolatableRobotFileWatermarkInstructionsInput;
-export type InterpolatableRobotFileWatermarkInstructionsInput = z.input<typeof interpolatableRobotFileWatermarkInstructionsSchema>;
-export declare const interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -143,8 +143,14 @@ export declare const interpolatableRobotFileWatermarkInstructionsWithHiddenField
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/file/watermark">;
     randomize: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof schemaVariants>;
+export type RobotFileWatermarkInstructions = Instructions['output'];
+export type RobotFileWatermarkInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFileWatermarkInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileWatermarkInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=file-watermark.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"file-watermark.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/file-watermark.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,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,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-watermark.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/file-watermark.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAE5F,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,EAEL,yBAAyB,EAI1B,MAAM,+BAA+B,CAAA;AAEtC,eAAO,MAAM,IAAI,EAAE,cAoBlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMtC,CAAA;AAEX,QAAA,MAAM,cAAc,EAAE,UAAU,CAC9B,OAAO,yBAAyB,CAAC,OAAO,oCAAoC,CAAC,KAAK,CAAC,CAClB,CAAA;AACnE,eAAO,MACa,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACtD,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEhE,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACpD,CAAA;AAElB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,cAAc,CAAC,CAAA;AAElE,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"}