@transloadit/zod 4.5.0 → 5.0.1

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

@@ -1,9 +1,8 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-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 +16,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)
@@ -61,49 +47,44 @@ Use \`grid\` to arrange inputs left-to-right and top-to-bottom.
 
 Only applies to the default spritesheet layout. Ignored when \`effect\` is set to \`polaroid-stack\` or \`mosaic\`, as those effects use their own layout algorithms.
 `),
-    effect: z
-        .enum(['mosaic', 'polaroid-stack'])
-        .optional()
+    effect: optionalWithV3Semantics(z
+        .enum(['mosaic', 'polaroid-stack']))
         .describe(`
 Applies a styled collage layout instead of a plain horizontal or vertical spritesheet.
 
 Currently supports \`polaroid-stack\`, which renders the inputs as overlapping instant photos on a canvas, and \`mosaic\`, which builds a justified tiled collage.
 `),
-    columns: z
+    columns: optionalWithV3Semantics(z
         .number()
         .int()
-        .min(1)
-        .optional()
+        .min(1))
         .describe(`
 Number of columns in the grid layout. Only applies when \`direction\` is \`grid\`.
 
 If omitted, columns are calculated automatically from the number of inputs and requested rows.
 `),
-    rows: z
+    rows: optionalWithV3Semantics(z
         .number()
         .int()
-        .min(1)
-        .optional()
+        .min(1))
         .describe(`
 Number of rows in the grid layout. Only applies when \`direction\` is \`grid\`.
 
 If omitted, rows are calculated automatically from the number of inputs and requested columns.
 `),
-    cell_width: z
+    cell_width: optionalWithV3Semantics(z
         .number()
         .int()
-        .min(1)
-        .optional()
+        .min(1))
         .describe(`
 Uniform width for each grid cell in pixels. Only applies when \`direction\` is \`grid\`.
 
 Images are resized to fit within the cell while preserving aspect ratio.
 `),
-    cell_height: z
+    cell_height: optionalWithV3Semantics(z
         .number()
         .int()
-        .min(1)
-        .optional()
+        .min(1))
         .describe(`
 Uniform height for each grid cell in pixels. Only applies when \`direction\` is \`grid\`.
 
@@ -121,39 +102,36 @@ 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
+    width: optionalWithV3Semantics(z
         .number()
         .int()
-        .positive()
-        .optional()
+        .positive())
         .describe(`
 The output canvas width in pixels.
 
 This is mainly used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
 `),
-    height: z
+    height: optionalWithV3Semantics(z
         .number()
         .int()
-        .positive()
-        .optional()
+        .positive())
         .describe(`
 The output canvas height in pixels.
 
 This is mainly used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
 `),
-    seed: z
+    seed: optionalWithV3Semantics(z
         .number()
-        .int()
-        .optional()
+        .int())
         .describe(`
 Optional deterministic seed used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
 `),
@@ -164,11 +142,10 @@ Optional deterministic seed used by styled effects such as \`polaroid-stack\` an
 Whether styled effects such as \`polaroid-stack\` and \`mosaic\` may shuffle the input order before laying out the canvas.
 `),
     sort_by: inputSortBySchema,
-    coverage: z
+    coverage: optionalWithV3Semantics(z
         .number()
         .min(0.5)
-        .max(3)
-        .optional()
+        .max(3))
         .describe(`
 Area-coverage multiplier for the \`polaroid-stack\` effect. Controls how large each polaroid is relative to the canvas and consequently how much of the canvas is covered by photos.
 
@@ -176,27 +153,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/v4/robots/image-ocr.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 robotImageOcrInstructionsSchema: 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";
@@ -35,29 +36,31 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
     provider: z.ZodDefault<z.ZodEnum<{
-        auto: "auto";
         aws: "aws";
         gcp: "gcp";
+        auto: "auto";
     }>>;
     granularity: z.ZodDefault<z.ZodEnum<{
         full: "full";
         list: "list";
     }>>;
     format: z.ZodDefault<z.ZodEnum<{
-        meta: "meta";
         json: "json";
         text: "text";
+        meta: "meta";
     }>>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotImageOcrInstructionsSchema.shape>;
 export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -82,38 +85,36 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
     provider: z.ZodDefault<z.ZodEnum<{
-        auto: "auto";
         aws: "aws";
         gcp: "gcp";
+        auto: "auto";
     }>>;
     granularity: z.ZodDefault<z.ZodEnum<{
         full: "full";
         list: "list";
     }>>;
     format: z.ZodDefault<z.ZodEnum<{
-        meta: "meta";
         json: "json";
         text: "text";
+        meta: "meta";
     }>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>;
-export type RobotImageOcrInstructionsWithHiddenFields = z.infer<typeof robotImageOcrInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotImageOcrInstructionsSchema: 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")[]>>]>>;
@@ -132,37 +133,35 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        auto: "auto";
+    provider: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         aws: "aws";
         gcp: "gcp";
+        auto: "auto";
     }>]>>;
-    granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    granularity: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         full: "full";
         list: "list";
     }>]>>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        meta: "meta";
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         json: "json";
         text: "text";
+        meta: "meta";
     }>]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
-export type InterpolatableRobotImageOcrInstructionsInput = z.input<typeof interpolatableRobotImageOcrInstructionsSchema>;
-export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -181,22 +180,28 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        auto: "auto";
+    provider: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         aws: "aws";
         gcp: "gcp";
+        auto: "auto";
     }>]>>;
-    granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    granularity: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         full: "full";
         list: "list";
     }>]>>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        meta: "meta";
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         json: "json";
         text: "text";
+        meta: "meta";
     }>]>>;
-    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 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/v4/robots/image-ocr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGxD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzE,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/v4/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAejC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,+BAA+B,CAAC,KAAK,CACtC,CAAA;AAEpD,eAAO,MACa,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACjD,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC7B,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC5E,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/v4/robots/image-ocr.js

@@ -1,45 +1,25 @@
 import { z } from 'zod/v4';
-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;

package/dist/v4/robots/image-optimize.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 robotImageOptimizeInstructionsSchema: 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";
@@ -43,15 +44,17 @@ export declare const robotImageOptimizeInstructionsSchema: z.ZodObject<{
     fix_breaking_images: z.ZodDefault<z.ZodBoolean>;
     lossy: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotImageOptimizeInstructionsSchema.shape>;
 export declare const robotImageOptimizeInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -84,24 +87,22 @@ export declare const robotImageOptimizeInstructionsWithHiddenFieldsSchema: z.Zod
     fix_breaking_images: z.ZodDefault<z.ZodBoolean>;
     lossy: z.ZodDefault<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotImageOptimizeInstructions = z.infer<typeof robotImageOptimizeInstructionsSchema>;
-export type RobotImageOptimizeInstructionsWithHiddenFields = z.infer<typeof robotImageOptimizeInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotImageOptimizeInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotImageOptimizeInstructionsSchema: 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")[]>>]>>;
@@ -120,31 +121,29 @@ export declare const interpolatableRobotImageOptimizeInstructionsSchema: z.ZodOb
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/optimize">;
-    priority: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    priority: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         "compression-ratio": "compression-ratio";
         "conversion-speed": "conversion-speed";
     }>]>>;
-    progressive: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    preserve_meta_data: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    fix_breaking_images: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    lossy: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotImageOptimizeInstructions = InterpolatableRobotImageOptimizeInstructionsInput;
-export type InterpolatableRobotImageOptimizeInstructionsInput = z.input<typeof interpolatableRobotImageOptimizeInstructionsSchema>;
-export declare const interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    progressive: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    preserve_meta_data: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    fix_breaking_images: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    lossy: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>, interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -163,16 +162,22 @@ export declare const interpolatableRobotImageOptimizeInstructionsWithHiddenField
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/optimize">;
-    priority: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    priority: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         "compression-ratio": "compression-ratio";
         "conversion-speed": "conversion-speed";
     }>]>>;
-    progressive: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    preserve_meta_data: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    fix_breaking_images: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    lossy: z.ZodDefault<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]>>]>>;
+    progressive: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    preserve_meta_data: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    fix_breaking_images: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    lossy: z.ZodPrefault<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 InterpolatableRobotImageOptimizeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotImageOptimizeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotImageOptimizeInstructions = Instructions['output'];
+export type RobotImageOptimizeInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotImageOptimizeInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageOptimizeInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageOptimizeInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotImageOptimizeInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=image-optimize.d.ts.map