@transloadit/zod 4.4.1 → 5.0.0

package/dist/v4/robots/document-extract.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 robotDocumentExtractInstructionsSchema: 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";
@@ -72,15 +73,17 @@ export declare const robotDocumentExtractInstructionsSchema: z.ZodObject<{
     dedupe_images: z.ZodDefault<z.ZodBoolean>;
     include_image_masks: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotDocumentExtractInstructionsSchema.shape>;
 export declare const robotDocumentExtractInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -142,24 +145,22 @@ export declare const robotDocumentExtractInstructionsWithHiddenFieldsSchema: z.Z
     dedupe_images: z.ZodDefault<z.ZodBoolean>;
     include_image_masks: z.ZodDefault<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotDocumentExtractInstructions = z.infer<typeof robotDocumentExtractInstructionsSchema>;
-export type RobotDocumentExtractInstructionsWithHiddenFields = z.infer<typeof robotDocumentExtractInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDocumentExtractInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDocumentExtractInstructionsSchema: 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")[]>>]>>;
@@ -178,7 +179,7 @@ export declare const interpolatableRobotDocumentExtractInstructionsSchema: z.Zod
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/extract">;
-    extract: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    extract: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         text: "text";
         images: "images";
     }>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -187,7 +188,7 @@ export declare const interpolatableRobotDocumentExtractInstructionsSchema: z.Zod
     }>]>>]>]>>;
     page_range: z.ZodOptional<z.ZodString>;
     password: z.ZodOptional<z.ZodString>;
-    text_method: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    text_method: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         native: "native";
         ocr: "ocr";
@@ -196,42 +197,40 @@ export declare const interpolatableRobotDocumentExtractInstructionsSchema: z.Zod
         aws: "aws";
         gcp: "gcp";
     }>]>>;
-    text_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    text_format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         json: "json";
         txt: "txt";
     }>]>>;
-    text_granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    text_granularity: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         document: "document";
         page: "page";
     }>]>>;
-    image_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    image_format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         jpg: "jpg";
         png: "png";
         original: "original";
     }>]>>;
-    min_image_width: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    min_image_height: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    min_image_bytes: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    dedupe_images: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    include_image_masks: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotDocumentExtractInstructions = InterpolatableRobotDocumentExtractInstructionsInput;
-export type InterpolatableRobotDocumentExtractInstructionsInput = z.input<typeof interpolatableRobotDocumentExtractInstructionsSchema>;
-export declare const interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    min_image_width: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_height: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_bytes: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    dedupe_images: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    include_image_masks: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>, interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -250,7 +249,7 @@ export declare const interpolatableRobotDocumentExtractInstructionsWithHiddenFie
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/extract">;
-    extract: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    extract: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         text: "text";
         images: "images";
     }>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -259,7 +258,7 @@ export declare const interpolatableRobotDocumentExtractInstructionsWithHiddenFie
     }>]>>]>]>>;
     page_range: z.ZodOptional<z.ZodString>;
     password: z.ZodOptional<z.ZodString>;
-    text_method: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    text_method: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         native: "native";
         ocr: "ocr";
@@ -268,27 +267,33 @@ export declare const interpolatableRobotDocumentExtractInstructionsWithHiddenFie
         aws: "aws";
         gcp: "gcp";
     }>]>>;
-    text_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    text_format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         json: "json";
         txt: "txt";
     }>]>>;
-    text_granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    text_granularity: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         document: "document";
         page: "page";
     }>]>>;
-    image_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    image_format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         jpg: "jpg";
         png: "png";
         original: "original";
     }>]>>;
-    min_image_width: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    min_image_height: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    min_image_bytes: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    dedupe_images: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    include_image_masks: 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]>>]>>;
+    min_image_width: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_height: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_bytes: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    dedupe_images: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    include_image_masks: 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 InterpolatableRobotDocumentExtractInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDocumentExtractInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDocumentExtractInstructions = Instructions['output'];
+export type RobotDocumentExtractInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDocumentExtractInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentExtractInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentExtractInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDocumentExtractInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=document-extract.d.ts.map

package/dist/v4/robots/document-extract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-extract.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-extract.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,cAoClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkGxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}
+{"version":3,"file":"document-extract.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-extract.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAkB1B,eAAO,MAAM,IAAI,EAAE,cAclB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqGxC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,sCAAsC,CAAC,KAAK,CACtC,CAAA;AAE3D,eAAO,MACa,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACxD,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAElE,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACrD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,gCAAgC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACrE,MAAM,MAAM,gDAAgD,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAC3F,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAChG,MAAM,MAAM,mDAAmD,GAC7D,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,8DAA8D,GACxE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,mEAAmE,GAC7E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v4/robots/document-extract.js

@@ -1,5 +1,7 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { ecmaWhitespaceCharacterClass } from "../lib/zodInputSemantics.js";
+import { createProcessingExample, defineRobot, robotBase, robotDocumentProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 const extractTargets = z.enum(['text', 'images']);
 const imageFormats = z.enum(['auto', 'original', 'png', 'jpg']);
 const ocrProviders = z.enum(['aws', 'gcp']);
@@ -7,41 +9,19 @@ const textFormats = z.enum(['txt', 'json']);
 const textGranularities = z.enum(['document', 'page']);
 const textMethods = z.enum(['native', 'ocr', 'auto']);
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            extracted: {
-                robot: '/document/extract',
-                use: ':original',
-                extract: ['text', 'images'],
-                text_method: 'native',
-            },
-        },
-    },
+    ...robotDocumentProcessingMeta,
+    example_code: createProcessingExample('extracted', '/document/extract', {
+        extract: ['text', 'images'],
+        text_method: 'native',
+    }),
     example_code_description: 'Extract native text and embedded raster images from a PDF document:',
-    minimum_charge: 1048576,
-    output_factor: 1,
-    override_lvl1: 'Document Processing',
     purpose_sentence: 'extracts text and embedded images from PDF documents',
     purpose_verb: 'extract',
     purpose_word: 'extracts text and images',
     purpose_words: 'Extracts text and embedded images',
-    service_slug: 'document-processing',
-    slot_count: 10,
     title: 'Extract text and images from documents',
-    typical_file_size_mb: 0.8,
-    typical_file_type: 'document',
     name: 'DocumentExtractRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
-    minimumCharge: 1048576,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'beta',
 };
 export const robotDocumentExtractInstructionsSchema = robotBase
     .merge(robotUse)
@@ -57,10 +37,9 @@ This robot does not render full pages. If you need page images, use \`/document/
         .describe(`
 Selects which assets to extract. Use \`["text"]\`, \`["images"]\`, or \`["text", "images"]\`.
 `),
-    page_range: z
+    page_range: optionalWithV3Semantics(z
         .string()
-        .regex(/^\s*\d+(?:\s*-\s*\d+)?(?:\s*,\s*\d+(?:\s*-\s*\d+)?)*\s*$/)
-        .optional()
+        .regex(new RegExp(`^${ecmaWhitespaceCharacterClass}*[0-9]+(?:${ecmaWhitespaceCharacterClass}*-${ecmaWhitespaceCharacterClass}*[0-9]+)?(?:${ecmaWhitespaceCharacterClass}*,${ecmaWhitespaceCharacterClass}*[0-9]+(?:${ecmaWhitespaceCharacterClass}*-${ecmaWhitespaceCharacterClass}*[0-9]+)?)*${ecmaWhitespaceCharacterClass}*$`, 'u')))
         .describe(`
 Optional comma-separated page selection, such as \`"1"\`, \`"1-3"\`, or \`"1,3-5"\`. Page numbers start at 1. Ranges are clamped to the detected page count.
 
@@ -68,9 +47,8 @@ At most 1,000 selected pages are allowed per job.
 
 This is supported for native text extraction and embedded image extraction. OCR extraction currently works on the full document.
 `),
-    password: z
-        .string()
-        .optional()
+    password: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Password used to unlock encrypted PDFs for native text extraction and embedded image extraction. OCR extraction currently does not support encrypted PDFs, so do not combine this with \`text_method: "ocr"\` or \`text_method: "auto"\`.
 `),
@@ -83,7 +61,7 @@ Controls how text is extracted.
 
 OCR modes currently cannot be combined with \`password\`.
 `),
-    ocr_provider: ocrProviders.optional().describe(`
+    ocr_provider: optionalWithV3Semantics(ocrProviders).describe(`
 OCR provider to use when \`text_method\` is \`"ocr"\` or \`"auto"\`. Valid values are \`"aws"\` and \`"gcp"\`.
 `),
     text_format: textFormats.default('txt').describe(`
@@ -142,10 +120,5 @@ When enabled, the robot also keeps image mask files when Poppler exposes them as
 `),
 })
     .strict();
-export const robotDocumentExtractInstructionsWithHiddenFieldsSchema = robotDocumentExtractInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotDocumentExtractInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotDocumentExtractInstructionsSchema = interpolateRobot(robotDocumentExtractInstructionsSchema);
-export const interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentExtractInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotDocumentExtractInstructionsSchema);
+export const { withHiddenFields: robotDocumentExtractInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotDocumentExtractInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/document-merge.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 robotDocumentMergeInstructionsSchema: 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";
@@ -42,15 +43,17 @@ export declare const robotDocumentMergeInstructionsSchema: z.ZodObject<{
         import_order: "import_order";
     }>>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotDocumentMergeInstructionsSchema.shape>;
 export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: 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,24 +85,22 @@ export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: z.Zod
         import_order: "import_order";
     }>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotDocumentMergeInstructions = z.infer<typeof robotDocumentMergeInstructionsSchema>;
-export type RobotDocumentMergeInstructionsWithHiddenFields = z.infer<typeof robotDocumentMergeInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDocumentMergeInstructionsSchema: 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")[]>>]>>;
@@ -118,30 +119,28 @@ export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodOb
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/merge">;
-    input_passwords: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>>;
+    input_passwords: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>>;
     output_password: z.ZodOptional<z.ZodString>;
-    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    sort_by: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         basename: "basename";
         import_order: "import_order";
     }>]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotDocumentMergeInstructions = InterpolatableRobotDocumentMergeInstructionsInput;
-export type InterpolatableRobotDocumentMergeInstructionsInput = z.input<typeof interpolatableRobotDocumentMergeInstructionsSchema>;
-export declare const interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -160,15 +159,21 @@ export declare const interpolatableRobotDocumentMergeInstructionsWithHiddenField
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/merge">;
-    input_passwords: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>>;
+    input_passwords: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>>;
     output_password: z.ZodOptional<z.ZodString>;
-    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    sort_by: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         basename: "basename";
         import_order: "import_order";
     }>]>>;
-    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 InterpolatableRobotDocumentMergeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDocumentMergeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDocumentMergeInstructions = Instructions['output'];
+export type RobotDocumentMergeInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDocumentMergeInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentMergeInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentMergeInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDocumentMergeInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=document-merge.d.ts.map

package/dist/v4/robots/document-merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cAoDlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"document-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-merge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBtC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,oCAAoC,CAAC,KAAK,CACtC,CAAA;AAEzD,eAAO,MACa,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACtD,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEhE,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACnD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,8BAA8B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACnE,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,iDAAiD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACnG,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,iEAAiE,GAC3E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,9 +1,8 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-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 +30,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)
@@ -67,19 +52,13 @@ This can be achieved via our as-syntax using "document_1", "document_2", etc if
 
 If the as-syntax is not used in the "use" parameter, the documents are sorted alphanumerically based on their filename, and in that order input passwords should be provided.
 `),
-    output_password: z
-        .string()
-        .optional()
+    output_password: optionalWithV3Semantics(z
+        .string())
         .describe(`
 If not empty, encrypts the output file and makes it accessible only by typing in this password.
 `),
     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;