@transloadit/zod 4.4.1 → 5.0.0

package/dist/v3/robots/image-merge.js

@@ -1,9 +1,7 @@
 import { z } from 'zod/v3';
-import { color_without_alpha_with_named, inputSortBySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { color_without_alpha_with_named, defineRobot, imageAdaptiveFilteringSchema, imageQualityValueSchema, inputSortBySchema, robotBase, robotImageProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
+    ...robotImageProcessingMeta,
     example_code: {
         steps: {
             merged: {
@@ -17,25 +15,12 @@ export const meta = {
         },
     },
     example_code_description: 'Merge uploaded images into one, with a 5px gap between them on the spritesheet:',
-    minimum_charge: 0,
-    output_factor: 0.6,
-    override_lvl1: 'Image Manipulation',
     purpose_sentence: 'merges several images into a single spritesheet',
     purpose_verb: 'merge',
     purpose_word: 'merge',
     purpose_words: 'Merge several images into one image',
-    service_slug: 'image-manipulation',
-    slot_count: 10,
     title: 'Merge several images into a single image',
-    typical_file_size_mb: 0.8,
-    typical_file_type: 'image',
     name: 'ImageMergeRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotImageMergeInstructionsSchema = robotBase
     .merge(robotUse)
@@ -121,14 +106,14 @@ A value of \`10\` would cause the images to have the largest gap between them, w
 
 When \`effect\` is \`polaroid-stack\`, this value is instead used as canvas padding so the outermost photos keep that many pixels of distance from the edge.
 
-When \`effect\` is \`mosaic\`, this value is used both as the outer canvas padding and as the gutter width between neighbouring tiles.
+When \`effect\` is \`mosaic\`, this value is used both as the outer canvas padding and as the gutter width between neighboring tiles.
 `),
     background: color_without_alpha_with_named.default('#fff').describe(`
 Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.php#color_names) of the color used to fill the background (only shown with a border > 1).
 
-By default, the background of transparent images is changed to white. Set to \`none\` or \`transparent\` for a transparent canvas — requires \`format\` \`png\` or \`webp\` to preserve alpha.
+By default, the background of transparent images is changed to white. Set to \`none\` or \`transparent\` for a transparent canvas — set \`format\` to \`png\` or \`webp\` to preserve alpha.
 
-For details about how to preserve transparency across all image types, see [this demo](/demos/image-manipulation/properly-preserve-transparency-across-all-image-types/).
+For details about how to preserve transparency across all image types, see [this demo](/demos/image-processing/properly-preserve-transparency-across-all-image-types/).
 `),
     width: z
         .number()
@@ -176,27 +161,11 @@ The default of \`1.5\` leaves a subtle beige border along some edges. Use \`2.0\
 
 Has no effect on the \`mosaic\` style or on plain spritesheets.
 `),
-    adaptive_filtering: z
-        .boolean()
-        .default(false)
-        .describe(`
-Controls the image compression for PNG images. Setting to \`true\` results in smaller file size, while increasing processing time. It is encouraged to keep this option disabled.
-`),
-    quality: z
-        .number()
-        .int()
-        .min(1)
-        .max(100)
-        .default(100)
-        .describe(`
+    adaptive_filtering: imageAdaptiveFilteringSchema,
+    quality: imageQualityValueSchema.default(100).describe(`
 Controls the image compression for JPG, PNG, and WebP images. Please also take a look at [🤖/image/optimize](/docs/robots/image-optimize/).
 `),
 })
     .strict();
-export const robotImageMergeInstructionsWithHiddenFieldsSchema = robotImageMergeInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotImageMergeInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotImageMergeInstructionsSchema = interpolateRobot(robotImageMergeInstructionsSchema);
-export const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageMergeInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotImageMergeInstructionsSchema);
+export const { withHiddenFields: robotImageMergeInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageMergeInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v3/robots/image-ocr.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 robotImageOcrInstructionsSchema: 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>;
@@ -63,14 +64,14 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
     granularity: z.ZodDefault<z.ZodEnum<["full", "list"]>>;
     format: z.ZodDefault<z.ZodEnum<["json", "meta", "text"]>>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/image/ocr";
     result: boolean;
+    robot: "/image/ocr";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    format: "meta" | "json" | "text";
-    provider: "auto" | "aws" | "gcp";
+    format: "json" | "text" | "meta";
+    provider: "aws" | "gcp" | "auto";
     granularity: "full" | "list";
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -85,11 +86,12 @@ export declare const robotImageOcrInstructionsSchema: 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: "/image/ocr";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -104,18 +106,21 @@ export declare const robotImageOcrInstructionsSchema: 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;
-    format?: "meta" | "json" | "text" | undefined;
-    provider?: "auto" | "aws" | "gcp" | undefined;
+    format?: "json" | "text" | "meta" | undefined;
+    provider?: "aws" | "gcp" | "auto" | undefined;
     granularity?: "full" | "list" | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotImageOcrInstructionsSchema.shape>;
 export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: 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")[]>>;
@@ -175,12 +180,13 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/image/ocr";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    format: "meta" | "json" | "text";
-    provider: "auto" | "aws" | "gcp";
+    format: "json" | "text" | "meta";
+    provider: "aws" | "gcp" | "auto";
     granularity: "full" | "list";
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -195,12 +201,12 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: 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: "/image/ocr";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -215,20 +221,19 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: 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;
-    format?: "meta" | "json" | "text" | undefined;
-    provider?: "auto" | "aws" | "gcp" | undefined;
+    format?: "json" | "text" | "meta" | undefined;
+    provider?: "aws" | "gcp" | "auto" | undefined;
     granularity?: "full" | "list" | undefined;
-}>;
-export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>;
-export type RobotImageOcrInstructionsWithHiddenFields = z.infer<typeof robotImageOcrInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotImageOcrInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotImageOcrInstructionsSchema: 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]>>;
@@ -286,14 +291,14 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
     granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["full", "list"]>]>>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["json", "meta", "text"]>]>>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/image/ocr";
     result: string | boolean;
+    robot: "/image/ocr";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     format: string;
     provider: string;
     granularity: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -308,11 +313,12 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: 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: "/image/ocr";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -327,20 +333,19 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: 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;
     format?: string | undefined;
     provider?: string | undefined;
     granularity?: string | undefined;
-}>;
-export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
-export type InterpolatableRobotImageOcrInstructionsInput = z.input<typeof interpolatableRobotImageOcrInstructionsSchema>;
-export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: 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")[]>]>>;
@@ -399,12 +404,13 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
     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, {
     robot: "/image/ocr";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     format: string;
     provider: string;
     granularity: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -419,12 +425,12 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
         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: "/image/ocr";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -439,8 +445,9 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
         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;
@@ -448,6 +455,12 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
     provider?: string | undefined;
     granularity?: string | undefined;
 }>;
-export type InterpolatableRobotImageOcrInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotImageOcrInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotImageOcrInstructions = Instructions['output'];
+export type RobotImageOcrInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotImageOcrInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageOcrInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageOcrInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotImageOcrInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=image-ocr.d.ts.map

package/dist/v3/robots/image-ocr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/image-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjC,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":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/image-ocr.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;AAa1B,eAAO,MAAM,IAAI,EAAE,cAoBlB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAejC,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/image-ocr.js

@@ -1,45 +1,25 @@
 import { z } from 'zod/v3';
-import { autoProviderDescription, awsGcpAiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { awsGcpAiProviderSchema, createProcessingExample, defineRobot, granularitySchema, robotArtificialIntelligenceMeta, robotBase, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            recognized: {
-                robot: '/image/ocr',
-                use: ':original',
-                provider: 'gcp',
-                format: 'text',
-            },
-        },
-    },
+    ...robotArtificialIntelligenceMeta,
+    example_code: createProcessingExample('recognized', '/image/ocr', {
+        provider: 'gcp',
+        format: 'text',
+    }),
     example_code_description: 'Recognize text in an uploaded image and save it to a text file:',
     extended_description: `
 > [!Warning]
 > Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses third-party AI services. The providers (AWS, GCP) will evolve their models over time, giving different responses for the same input images. Avoid relying on exact responses in your tests and application.
 `,
-    minimum_charge: 1048576,
-    output_factor: 0.6,
     override_lvl1: 'Artificial Intelligence',
     purpose_sentence: 'recognizes text in images and returns it in a machine-readable format',
     purpose_verb: 'recognize',
     purpose_word: 'recognize text',
     purpose_words: 'Recognize text in images (OCR)',
-    service_slug: 'artificial-intelligence',
-    slot_count: 10,
     title: 'Recognize text in images',
     typical_file_size_mb: 0.8,
-    typical_file_type: 'image',
     name: 'ImageOcrRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsd: 0.0013,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotImageOcrInstructionsSchema = robotBase
     .merge(robotUse)
@@ -49,29 +29,13 @@ With this <dfn>Robot</dfn> you can detect and extract text from images using opt
 
 For example, you can use the results to obtain the content of traffic signs, name tags, package labels and many more. You can also pass the text down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain phrases. For images of dense documents, results may vary and be less accurate than for small pieces of text in photos.
 `),
-    provider: awsGcpAiProviderSchema.describe(`
-${autoProviderDescription}
-
-Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
-
-AWS supports detection for the following languages: English, Arabic, Russian, German, French, Italian, Portuguese and Spanish. GCP allows for a wider range of languages, with varying levels of support which can be found on the [official documentation](https://cloud.google.com/vision/docs/languages/).
-`),
-    granularity: granularitySchema.describe(`
-Whether to return a full response including coordinates for the text (\`"full"\`), or a flat list of the extracted phrases (\`"list"\`). This parameter has no effect if the \`format\` parameter is set to \`"text"\`.
-`),
+    provider: awsGcpAiProviderSchema.describe(robotParameterDocs.ocr_provider.description),
+    granularity: granularitySchema.describe(robotParameterDocs.ocr_granularity.description),
     format: z
         .enum(['json', 'meta', 'text'])
         .default('json')
-        .describe(`
-In what format to return the extracted text.
-- \`"json"\` returns a JSON file.
-- \`"meta"\` does not return a file, but stores the data inside Transloadit's file object (under \`\${file.meta.recognized_text}\`, which is an array of strings) that's passed around between encoding <dfn>Steps</dfn>, so that you can use the values to burn the data into videos, filter on them, etc.
-- \`"text"\` returns the recognized text as a plain UTF-8 encoded text file.
-`),
+        .describe(robotParameterDocs.ocr_format.description),
 })
     .strict();
-export const robotImageOcrInstructionsWithHiddenFieldsSchema = robotImageOcrInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotImageOcrInstructionsSchema.shape.result]).optional(),
-});
-export const interpolatableRobotImageOcrInstructionsSchema = interpolateRobot(robotImageOcrInstructionsSchema);
-export const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageOcrInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotImageOcrInstructionsSchema);
+export const { withHiddenFields: robotImageOcrInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageOcrInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema, } = robotDefinition;