@transloadit/zod 4.5.0 → 5.0.1

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

@@ -1,9 +1,7 @@
 import { z } from 'zod/v3';
-import { inputSortBySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { defineRobot, inputSortBySchema, robotBase, robotDocumentProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
+    ...robotDocumentProcessingMeta,
     example_code: {
         steps: {
             merged: {
@@ -31,27 +29,13 @@ Input files are sorted alphanumerically unless you provide the as-syntax in the
 }
 \`\`\`
 `,
-    minimum_charge: 1048576,
-    output_factor: 1,
-    override_lvl1: 'Document Processing',
     purpose_sentence: 'concatenates several PDF documents into a single file',
     purpose_verb: 'convert',
     purpose_word: 'convert',
     purpose_words: 'Merge documents into one',
-    service_slug: 'document-processing',
-    slot_count: 10,
     title: 'Merge documents into one',
-    typical_file_size_mb: 0.8,
-    typical_file_type: 'document',
     name: 'DocumentMergeRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
-    minimumCharge: 1048576,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotDocumentMergeInstructionsSchema = robotBase
     .merge(robotUse)
@@ -76,10 +60,5 @@ If not empty, encrypts the output file and makes it accessible only by typing in
     sort_by: inputSortBySchema,
 })
     .strict();
-export const robotDocumentMergeInstructionsWithHiddenFieldsSchema = robotDocumentMergeInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotDocumentMergeInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotDocumentMergeInstructionsSchema = interpolateRobot(robotDocumentMergeInstructionsSchema);
-export const interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentMergeInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotDocumentMergeInstructionsSchema);
+export const { withHiddenFields: robotDocumentMergeInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotDocumentMergeInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v3/robots/document-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 robotDocumentOcrInstructionsSchema: 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 robotDocumentOcrInstructionsSchema: z.ZodObject<{
     granularity: z.ZodDefault<z.ZodEnum<["full", "list"]>>;
     format: z.ZodDefault<z.ZodEnum<["json", "meta", "text"]>>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/document/ocr";
     result: boolean;
+    robot: "/document/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 robotDocumentOcrInstructionsSchema: 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: "/document/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 robotDocumentOcrInstructionsSchema: 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 robotDocumentOcrInstructionsSchema.shape>;
 export declare const robotDocumentOcrInstructionsWithHiddenFieldsSchema: 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 robotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodOb
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/document/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 robotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodOb
         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: "/document/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 robotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodOb
         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 RobotDocumentOcrInstructions = z.infer<typeof robotDocumentOcrInstructionsSchema>;
-export type RobotDocumentOcrInstructionsWithHiddenFields = z.infer<typeof robotDocumentOcrInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDocumentOcrInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotDocumentOcrInstructionsSchema: 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 interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObje
     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: "/document/ocr";
     result: string | boolean;
+    robot: "/document/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 interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObje
         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: "/document/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 interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObje
         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 InterpolatableRobotDocumentOcrInstructions = InterpolatableRobotDocumentOcrInstructionsInput;
-export type InterpolatableRobotDocumentOcrInstructionsInput = z.input<typeof interpolatableRobotDocumentOcrInstructionsSchema>;
-export declare const interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema: 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 interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsS
     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: "/document/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 interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsS
         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: "/document/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 interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsS
         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 interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsS
     provider?: string | undefined;
     granularity?: string | undefined;
 }>;
-export type InterpolatableRobotDocumentOcrInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDocumentOcrInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDocumentOcrInstructions = Instructions['output'];
+export type RobotDocumentOcrInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDocumentOcrInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentOcrInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentOcrInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDocumentOcrInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=document-ocr.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"document-ocr.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/document-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,cA6ClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK3D,CAAA;AAEJ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE5D,CAAA;AACD,MAAM,MAAM,0CAA0C,GACpD,+CAA+C,CAAA;AAEjD,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,gDAAgD,CACxD,CAAA;AAED,eAAO,MAAM,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE5E,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,gEAAgE,CACxE,CAAA;AACD,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,gEAAgE,CACxE,CAAA"}
+{"version":3,"file":"document-ocr.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/document-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,cA0BlB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAepC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,kCAAkC,CAAC,KAAK,CACtC,CAAA;AAEvD,eAAO,MACa,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACpD,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAChC,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC/E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,4BAA4B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACjE,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACvF,MAAM,MAAM,0CAA0C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC5F,MAAM,MAAM,+CAA+C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACjG,MAAM,MAAM,0DAA0D,GACpE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,+DAA+D,GACzE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v3/robots/document-ocr.js

@@ -1,18 +1,10 @@
 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: '/document/ocr',
-                use: ':original',
-                provider: 'gcp',
-            },
-        },
-    },
+    ...robotArtificialIntelligenceMeta,
+    example_code: createProcessingExample('recognized', '/document/ocr', {
+        provider: 'gcp',
+    }),
     example_code_description: 'Recognize text in an uploaded document and save it to a JSON file:',
     extended_description: `
 > [!Warning]
@@ -21,30 +13,19 @@ export const meta = {
 > [!Note]
 > Currently, this <dfn>Robot</dfn> only supports character recognition for PDFs. To use this <dfn>Robot</dfn> with other document formats, use [/document/convert](/docs/robots/document-convert/) first to convert the document into a PDF.
 `,
-    minimum_charge: 1048576,
-    output_factor: 1,
     override_lvl1: 'Artificial Intelligence',
     purpose_sentence: 'recognizes text in documents and returns it in a machine-readable format',
     purpose_verb: 'recognize',
     purpose_word: 'recognize text',
     purpose_words: 'Recognize text in documents (OCR)',
-    service_slug: 'artificial-intelligence',
-    slot_count: 10,
     title: 'Recognize text in documents',
     typical_file_size_mb: 0.8,
     typical_file_type: 'document',
     name: 'DocumentOcrRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsdPerDocumentOcrPage: {
         aws: 0.02,
         gcp: 0.015,
     },
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotDocumentOcrInstructionsSchema = robotBase
     .merge(robotUse)
@@ -54,31 +35,13 @@ With this <dfn>Robot</dfn>, you can detect and extract text from PDFs using opti
 
 For example, you can use the results to obtain the content of invoices, legal documents or restaurant menus. You can also pass the text down to other <dfn>Robots</dfn> to filter documents that contain (or do not contain) certain phrases.
 `),
-    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 robotDocumentOcrInstructionsWithHiddenFieldsSchema = robotDocumentOcrInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotDocumentOcrInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotDocumentOcrInstructionsSchema = interpolateRobot(robotDocumentOcrInstructionsSchema);
-export const interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentOcrInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotDocumentOcrInstructionsSchema);
+export const { withHiddenFields: robotDocumentOcrInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotDocumentOcrInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema, } = robotDefinition;