transloadit 4.13.1 → 5.0.0

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

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod';
 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">]>>;
+    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 robotFileHashInstructionsSchema: 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 robotFileHashInstructionsSchema: 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 robotFileHashInstructionsSchema: 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 robotFileHashInstructionsSchema: z.ZodObject<{
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -64,58 +65,62 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
     partial_size: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     partial: "last" | "full" | "first" | "both";
+    user_meta: Record<string, unknown>;
     robot: "/file/hash";
     result: boolean;
     force_accept: boolean;
     ignore_errors: string[];
-    algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
+    algorithm: "sha256" | "b2" | "md5" | "sha1" | "sha224" | "sha384" | "sha512";
     partial_size: number;
-    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/hash";
     partial?: "last" | "full" | "first" | "both" | undefined;
-    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;
-    algorithm?: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512" | undefined;
+    algorithm?: "sha256" | "b2" | "md5" | "sha1" | "sha224" | "sha384" | "sha512" | undefined;
     partial_size?: number | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotFileHashInstructionsSchema.shape>;
 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">]>>;
+    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")[]>>;
@@ -125,12 +130,12 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
         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;
@@ -138,12 +143,12 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
             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>;
@@ -151,8 +156,8 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     }, "strict", z.ZodTypeAny, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -160,8 +165,8 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -175,60 +180,60 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     partial: "last" | "full" | "first" | "both";
+    user_meta: Record<string, unknown>;
     robot: "/file/hash";
     force_accept: boolean;
     ignore_errors: string[];
-    algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
+    algorithm: "sha256" | "b2" | "md5" | "sha1" | "sha224" | "sha384" | "sha512";
     partial_size: number;
-    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;
 }, {
     robot: "/file/hash";
     partial?: "last" | "full" | "first" | "both" | undefined;
-    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;
-    algorithm?: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512" | undefined;
+    algorithm?: "sha256" | "b2" | "md5" | "sha1" | "sha224" | "sha384" | "sha512" | undefined;
     partial_size?: number | undefined;
-}>;
-export type RobotFileHashInstructions = z.infer<typeof robotFileHashInstructionsSchema>;
-export type RobotFileHashInstructionsWithHiddenFields = z.infer<typeof robotFileHashInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<{
+}>, 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">]>]>>;
+    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]>>;
@@ -239,12 +244,12 @@ export declare const interpolatableRobotFileHashInstructionsSchema: 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;
@@ -252,12 +257,12 @@ export declare const interpolatableRobotFileHashInstructionsSchema: 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>;
@@ -265,8 +270,8 @@ export declare const interpolatableRobotFileHashInstructionsSchema: 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;
@@ -274,8 +279,8 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -287,60 +292,60 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     partial_size: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
     partial: string;
+    user_meta: Record<string, unknown>;
     robot: "/file/hash";
     result: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     algorithm: string;
     partial_size: string | number;
-    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/hash";
     partial?: string | undefined;
-    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;
     algorithm?: string | undefined;
     partial_size?: string | number | undefined;
-}>;
-export type InterpolatableRobotFileHashInstructions = InterpolatableRobotFileHashInstructionsInput;
-export type InterpolatableRobotFileHashInstructionsInput = z.input<typeof interpolatableRobotFileHashInstructionsSchema>;
-export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}>, 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">]>]>>;
+    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")[]>]>>;
@@ -350,12 +355,12 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
         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;
@@ -363,12 +368,12 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
             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>;
@@ -376,8 +381,8 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     }, "strict", z.ZodTypeAny, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -385,8 +390,8 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     }, {
         steps: string | string[] | {
             name: string;
-            fields?: string | undefined;
             as?: string | undefined;
+            fields?: string | undefined;
         }[];
         fields?: string[] | undefined;
         bundle_steps?: boolean | undefined;
@@ -399,55 +404,63 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, "strict", z.ZodTypeAny, {
     partial: string;
+    user_meta: Record<string, unknown>;
     robot: "/file/hash";
     force_accept: string | boolean;
     ignore_errors: string | string[];
     algorithm: string;
     partial_size: string | number;
-    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;
 }, {
     robot: "/file/hash";
     partial?: string | undefined;
-    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;
     algorithm?: string | undefined;
     partial_size?: string | number | undefined;
 }>;
-export type InterpolatableRobotFileHashInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileHashInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotFileHashInstructions = Instructions['output'];
+export type RobotFileHashInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFileHashInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileHashInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileHashInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFileHashInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=file-hash.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-hash.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,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/alphalib/types/robots/file-hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,IAAI,EAAE,cAelB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BjC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,+BAA+B,CAAC,KAAK,CACtC,CAAA;AAEpD,eAAO,MACa,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACjD,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC7B,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC5E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,yBAAyB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAC9D,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACpF,MAAM,MAAM,uCAAuC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,uDAAuD,GACjE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,38 +1,21 @@
 import { z } from 'zod';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { fileHashOptionsSchema } from "../fileHash.js";
+import { createProcessingExample, defineRobot, robotBase, robotMediaCatalogingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 5,
-    discount_factor: 0.2,
-    discount_pct: 80,
-    example_code: {
-        steps: {
-            hashed: {
-                robot: '/file/hash',
-                use: ':original',
-                algorithm: 'sha1',
-            },
-        },
-    },
+    ...robotMediaCatalogingMeta,
+    example_code: createProcessingExample('hashed', '/file/hash', {
+        algorithm: 'sha1',
+    }),
     example_code_description: 'Hash each uploaded file using the SHA-1 algorithm:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'Media Cataloging',
     purpose_sentence: 'hashes files in Assemblies',
     purpose_verb: 'hash',
     purpose_word: 'file',
     purpose_words: 'Hash files',
-    service_slug: 'media-cataloging',
-    slot_count: 60,
     title: 'Hash Files',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'FileHashRobot',
     priceFactor: 5,
     queueSlotCount: 60,
     isAllowedForUrlTransform: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotFileHashInstructionsSchema = robotBase
     .merge(robotUse)
@@ -40,18 +23,12 @@ export const robotFileHashInstructionsSchema = robotBase
     robot: z.literal('/file/hash').describe(`
 This <dfn>Robot</dfn> allows you to hash any file as part of the <dfn>Assembly</dfn> execution process. This can be useful for verifying the integrity of a file for example.
 `),
-    algorithm: z
-        .enum(['b2', 'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'])
-        .default('sha256')
-        .describe(`
+    algorithm: fileHashOptionsSchema.shape.algorithm.describe(`
 The hashing algorithm to use.
 
 The file hash is exported as \`file.meta.hash\`.
 `),
-    partial: z
-        .enum(['full', 'first', 'last', 'both'])
-        .default('full')
-        .describe(`
+    partial: fileHashOptionsSchema.shape.partial.describe(`
 Specifies which portion of the file to hash. This is useful for fast fingerprinting of large files.
 
 - \`"full"\` (default): Hash the entire file.
@@ -61,21 +38,13 @@ Specifies which portion of the file to hash. This is useful for fast fingerprint
 
 When using partial hashing, \`file.meta.hash_partial\` indicates the mode used, and \`file.meta.hash_partial_size\` indicates the number of bytes hashed from each portion.
 `),
-    partial_size: z
-        .number()
-        .int()
-        .positive()
-        .default(1048576)
-        .describe(`
-The number of bytes to hash when using partial hashing. Defaults to \`1048576\` (1 MB).
+    partial_size: fileHashOptionsSchema.shape.partialSize.describe(`
+The number of bytes to hash when using partial hashing. Defaults to \`${fileHashOptionsSchema.shape.partialSize.parse(undefined)}\` (1 MB).
 
 This parameter is only used when \`partial\` is set to \`"first"\`, \`"last"\`, or \`"both"\`.
 `),
 })
     .strict();
-export const robotFileHashInstructionsWithHiddenFieldsSchema = robotFileHashInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotFileHashInstructionsSchema.shape.result]).optional(),
-});
-export const interpolatableRobotFileHashInstructionsSchema = interpolateRobot(robotFileHashInstructionsSchema);
-export const interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileHashInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotFileHashInstructionsSchema);
+export const { withHiddenFields: robotFileHashInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFileHashInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema, } = robotDefinition;
 //# sourceMappingURL=file-hash.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"file-hash.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-hash.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,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,EAAE;IAChB,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,MAAM,EAAE;gBACN,KAAK,EAAE,YAAY;gBACnB,GAAG,EAAE,WAAW;gBAChB,SAAS,EAAE,MAAM;aAClB;SACF;KACF;IACD,wBAAwB,EAAE,oDAAoD;IAC9E,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,kBAAkB;IACjC,gBAAgB,EAAE,4BAA4B;IAC9C,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,MAAM;IACpB,aAAa,EAAE,YAAY;IAC3B,YAAY,EAAE,kBAAkB;IAChC,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,YAAY;IACnB,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;IACzB,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,CAAC;IACd,cAAc,EAAE,EAAE;IAClB,wBAAwB,EAAE,KAAK;IAC/B,UAAU,EAAE,KAAK;IACjB,iDAAiD,EAAE,KAAK;IACxD,KAAK,EAAE,IAAI;CACZ,CAAA;AAED,MAAM,CAAC,MAAM,+BAA+B,GAAG,SAAS;KACrD,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC;;CAE3C,CAAC;IACE,SAAS,EAAE,CAAC;SACT,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;SACnE,OAAO,CAAC,QAAQ,CAAC;SACjB,QAAQ,CAAC;;;;CAIf,CAAC;IACE,OAAO,EAAE,CAAC;SACP,IAAI,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;SACvC,OAAO,CAAC,MAAM,CAAC;SACf,QAAQ,CAAC;;;;;;;;;CASf,CAAC;IACE,YAAY,EAAE,CAAC;SACZ,MAAM,EAAE;SACR,GAAG,EAAE;SACL,QAAQ,EAAE;SACV,OAAO,CAAC,OAAO,CAAC;SAChB,QAAQ,CAAC;;;;CAIf,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,+CAA+C,GAC1D,+BAA+B,CAAC,MAAM,CAAC;IACrC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,+BAA+B,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC/F,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,6CAA6C,GAAG,gBAAgB,CAC3E,+BAA+B,CAChC,CAAA;AAOD,MAAM,CAAC,MAAM,6DAA6D,GAAG,gBAAgB,CAC3F,+CAA+C,CAChD,CAAA"}
+{"version":3,"file":"file-hash.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-hash.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,SAAS,EACT,wBAAwB,EACxB,QAAQ,GACT,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,GAAG,wBAAwB;IAC3B,YAAY,EAAE,uBAAuB,CAAC,QAAQ,EAAE,YAAY,EAAE;QAC5D,SAAS,EAAE,MAAM;KAClB,CAAC;IACF,wBAAwB,EAAE,oDAAoD;IAC9E,gBAAgB,EAAE,4BAA4B;IAC9C,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,MAAM;IACpB,aAAa,EAAE,YAAY;IAC3B,KAAK,EAAE,YAAY;IACnB,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,CAAC;IACd,cAAc,EAAE,EAAE;IAClB,wBAAwB,EAAE,KAAK;CAChC,CAAA;AAED,MAAM,CAAC,MAAM,+BAA+B,GAAG,SAAS;KACrD,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC;;CAE3C,CAAC;IACE,SAAS,EAAE,qBAAqB,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC;;;;CAI7D,CAAC;IACE,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;;;;;;;;;CASzD,CAAC;IACE,YAAY,EAAE,qBAAqB,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC;wEACK,qBAAqB,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,SAAS,CAAC;;;CAG/H,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,eAAe,GAC1B,WAAW,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;AAEpD,MAAM,CAAC,MAAM,EACX,gBAAgB,EAAE,+CAA+C,EACjE,cAAc,EAAE,6CAA6C,EAC7D,8BAA8B,EAAE,6DAA6D,GAC9F,GAAG,eAAe,CAAA"}