@transloadit/zod 4.4.1 → 5.0.0

package/dist/v4/robots/document-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 robotDocumentOcrInstructionsSchema: 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 robotDocumentOcrInstructionsSchema: z.ZodObject<{
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/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 robotDocumentOcrInstructionsSchema.shape>;
 export declare const robotDocumentOcrInstructionsWithHiddenFieldsSchema: 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 robotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodOb
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/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 RobotDocumentOcrInstructions = z.infer<typeof robotDocumentOcrInstructionsSchema>;
-export type RobotDocumentOcrInstructionsWithHiddenFields = z.infer<typeof robotDocumentOcrInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDocumentOcrInstructionsSchema: 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 interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObje
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/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 InterpolatableRobotDocumentOcrInstructions = InterpolatableRobotDocumentOcrInstructionsInput;
-export type InterpolatableRobotDocumentOcrInstructionsInput = z.input<typeof interpolatableRobotDocumentOcrInstructionsSchema>;
-export declare const interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema: 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 interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsS
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/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 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/v4/robots/document-ocr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5E,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/v4/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAepC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,kCAAkC,CAAC,KAAK,CACtC,CAAA;AAEvD,eAAO,MACa,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACpD,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAChC,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC/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/v4/robots/document-ocr.js

@@ -1,18 +1,10 @@
 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: '/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;

package/dist/v4/robots/document-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 robotDocumentOptimizeInstructionsSchema: 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";
@@ -53,15 +54,17 @@ export declare const robotDocumentOptimizeInstructionsSchema: z.ZodObject<{
         "2.0": "2.0";
     }>>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotDocumentOptimizeInstructionsSchema.shape>;
 export declare const robotDocumentOptimizeInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -104,24 +107,22 @@ export declare const robotDocumentOptimizeInstructionsWithHiddenFieldsSchema: z.
         "2.0": "2.0";
     }>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotDocumentOptimizeInstructions = z.infer<typeof robotDocumentOptimizeInstructionsSchema>;
-export type RobotDocumentOptimizeInstructionsWithHiddenFields = z.infer<typeof robotDocumentOptimizeInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDocumentOptimizeInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDocumentOptimizeInstructionsSchema: 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")[]>>]>>;
@@ -140,41 +141,39 @@ export declare const interpolatableRobotDocumentOptimizeInstructionsSchema: z.Zo
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/optimize">;
-    preset: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    preset: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         ebook: "ebook";
         screen: "screen";
         printer: "printer";
         prepress: "prepress";
     }>]>>;
     image_dpi: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    compress_fonts: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    subset_fonts: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    remove_metadata: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    linearize: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    compatibility: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    compress_fonts: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    subset_fonts: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    remove_metadata: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    linearize: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    compatibility: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         1.4: "1.4";
         1.5: "1.5";
         1.6: "1.6";
         1.7: "1.7";
         "2.0": "2.0";
     }>]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotDocumentOptimizeInstructions = InterpolatableRobotDocumentOptimizeInstructionsInput;
-export type InterpolatableRobotDocumentOptimizeInstructionsInput = z.input<typeof interpolatableRobotDocumentOptimizeInstructionsSchema>;
-export declare const interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -193,26 +192,32 @@ export declare const interpolatableRobotDocumentOptimizeInstructionsWithHiddenFi
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/document/optimize">;
-    preset: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    preset: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         ebook: "ebook";
         screen: "screen";
         printer: "printer";
         prepress: "prepress";
     }>]>>;
     image_dpi: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    compress_fonts: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    subset_fonts: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    remove_metadata: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    linearize: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    compatibility: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    compress_fonts: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    subset_fonts: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    remove_metadata: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    linearize: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    compatibility: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         1.4: "1.4";
         1.5: "1.5";
         1.6: "1.6";
         1.7: "1.7";
         "2.0": "2.0";
     }>]>>;
-    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 InterpolatableRobotDocumentOptimizeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDocumentOptimizeInstructions = Instructions['output'];
+export type RobotDocumentOptimizeInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDocumentOptimizeInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentOptimizeInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentOptimizeInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=document-optimize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"document-optimize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-optimize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAwDlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkFzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,qEAAqE,CAC7E,CAAA;AACD,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA"}
+{"version":3,"file":"document-optimize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-optimize.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,cAqClB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiFzC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,uCAAuC,CAAC,KAAK,CACQ,CAAA;AAE9D,eAAO,MACa,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACzD,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEnE,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACtD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,iCAAiC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACtE,MAAM,MAAM,iDAAiD,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAC5F,MAAM,MAAM,+CAA+C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACjG,MAAM,MAAM,oDAAoD,GAC9D,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,+DAA+D,GACzE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,oEAAoE,GAC9E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,18 +1,11 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobot, robotBase, robotDocumentProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            optimized: {
-                robot: '/document/optimize',
-                use: ':original',
-                preset: 'ebook',
-            },
-        },
-    },
+    ...robotDocumentProcessingMeta,
+    example_code: createProcessingExample('optimized', '/document/optimize', {
+        preset: 'ebook',
+    }),
     example_code_description: 'Optimize PDF file size using the ebook preset:',
     extended_description: `
 This <dfn>Robot</dfn> reduces PDF file sizes. It recompresses images, subsets fonts, and applies various optimizations to reduce file size while maintaining acceptable quality.
@@ -35,26 +28,15 @@ The Robot supports four quality presets that control the trade-off between file
 - Meeting email attachment size limits
 - Mobile-optimized document viewing
 `,
-    minimum_charge: 2097152,
-    output_factor: 0.5,
-    override_lvl1: 'Document Processing',
     purpose_sentence: 'reduces the file size of PDF documents',
     purpose_verb: 'optimize',
     purpose_word: 'optimize PDF',
     purpose_words: 'Optimize PDF file size',
-    service_slug: 'document-processing',
-    slot_count: 10,
     title: 'Reduce PDF file size',
     typical_file_size_mb: 2.0,
-    typical_file_type: 'document',
     name: 'DocumentOptimizeRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumCharge: 2097152,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
     stage: 'beta',
 };
 export const robotDocumentOptimizeInstructionsSchema = robotBase
@@ -85,12 +67,11 @@ The quality preset to use for optimization. Each preset provides a different bal
 - \`printer\` - High quality suitable for printing. Images are kept at 300 DPI.
 - \`prepress\` - Highest quality for professional printing. Minimal compression applied.
 `),
-    image_dpi: z
+    image_dpi: optionalWithV3Semantics(z
         .number()
         .int()
         .min(36)
-        .max(600)
-        .optional()
+        .max(600))
         .describe(`
 Target DPI (dots per inch) for embedded images. When specified, this overrides the DPI setting from the preset.
 
@@ -140,10 +121,5 @@ The PDF version compatibility level. Lower versions have broader compatibility b
 `),
 })
     .strict();
-export const robotDocumentOptimizeInstructionsWithHiddenFieldsSchema = robotDocumentOptimizeInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotDocumentOptimizeInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotDocumentOptimizeInstructionsSchema = interpolateRobot(robotDocumentOptimizeInstructionsSchema);
-export const interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentOptimizeInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotDocumentOptimizeInstructionsSchema);
+export const { withHiddenFields: robotDocumentOptimizeInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotDocumentOptimizeInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema, } = robotDefinition;