@transloadit/zod 4.4.1 → 5.0.0

package/dist/v3/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/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotFileHashInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -64,13 +65,13 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
     partial_size: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     partial: "full" | "last" | "first" | "both";
-    robot: "/file/hash";
     result: boolean;
+    robot: "/file/hash";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
+    algorithm: "b2" | "md5" | "sha1" | "sha224" | "sha256" | "sha384" | "sha512";
     partial_size: number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -85,12 +86,13 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
 }, {
     robot: "/file/hash";
     partial?: "full" | "last" | "first" | "both" | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -105,17 +107,20 @@ export declare const robotFileHashInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
-    algorithm?: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512" | undefined;
+    algorithm?: "b2" | "md5" | "sha1" | "sha224" | "sha256" | "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">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
@@ -176,11 +181,12 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
 }, "strict", z.ZodTypeAny, {
     partial: "full" | "last" | "first" | "both";
     robot: "/file/hash";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    algorithm: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512";
+    algorithm: "b2" | "md5" | "sha1" | "sha224" | "sha256" | "sha384" | "sha512";
     partial_size: number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -195,13 +201,13 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
         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?: "full" | "last" | "first" | "both" | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -216,19 +222,18 @@ export declare const robotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObjec
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
-    algorithm?: "sha1" | "b2" | "md5" | "sha224" | "sha256" | "sha384" | "sha512" | undefined;
+    algorithm?: "b2" | "md5" | "sha1" | "sha224" | "sha256" | "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<{
-    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">>]>>;
+}>, interpolatableRobotFileHashInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -287,13 +292,13 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
     partial_size: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
     partial: string;
-    robot: "/file/hash";
     result: string | boolean;
+    robot: "/file/hash";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     algorithm: string;
     partial_size: string | number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -308,12 +313,13 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
         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;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -328,19 +334,18 @@ export declare const interpolatableRobotFileHashInstructionsSchema: z.ZodObject<
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     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<{
-    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">>]>>;
+}>, interpolatableRobotFileHashInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
@@ -400,11 +405,12 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
 }, "strict", z.ZodTypeAny, {
     partial: string;
     robot: "/file/hash";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     algorithm: string;
     partial_size: string | number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -419,13 +425,13 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
         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;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -440,14 +446,21 @@ export declare const interpolatableRobotFileHashInstructionsWithHiddenFieldsSche
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     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/v3/robots/file-hash.d.ts.map

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

@@ -1,38 +1,21 @@
 import { z } from 'zod/v3';
-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,20 +38,12 @@ 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;