@transloadit/zod 4.5.0 → 5.0.1

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

@@ -1,47 +1,25 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { autoProviderDescription, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, createProcessingExample, defineRobot, robotBase, robotImageProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    discount_factor: 1,
-    bytescount: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            remove_background: {
-                robot: '/image/bgremove',
-                use: ':original',
-            },
-        },
-    },
+    ...robotImageProcessingMeta,
+    example_code: createProcessingExample('remove_background', '/image/bgremove'),
     example_code_description: 'Remove the background from the uploaded image:',
-    minimum_charge: 0,
-    output_factor: 0.6,
-    override_lvl1: 'Image Manipulation',
     purpose_sentence: 'removes the background from images',
     purpose_verb: 'remove',
     purpose_word: 'remove',
     purpose_words: 'Remove the background from images',
-    service_slug: 'image-manipulation',
-    slot_count: 10,
     title: 'Remove the background from images',
-    typical_file_size_mb: 0.8,
-    typical_file_type: 'image',
     name: 'ImageBgremoveRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsd: 0.006,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotImageBgremoveInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/image/bgremove'),
-    select: z
-        .enum(['foreground', 'background'])
-        .optional()
+    select: optionalWithV3Semantics(z
+        .enum(['foreground', 'background']))
         .describe('Region to select and keep in the image. The other region is removed.'),
     format: z
         .enum(['png', 'gif', 'webp'])
@@ -50,17 +28,11 @@ export const robotImageBgremoveInstructionsSchema = robotBase
     provider: z
         .enum(['auto', 'transloadit', 'replicate', 'fal'])
         .default('auto')
-        .describe(`${autoProviderDescription} Set this to \`"transloadit"\`, \`"replicate"\`, or \`"fal"\` to force a specific provider.`),
-    model: z
-        .string()
-        .optional()
+        .describe(`${autoProviderDescription}\n\nSelect a specific provider to override automatic selection.`),
+    model: optionalWithV3Semantics(z
+        .string())
         .describe('Provider-specific model to use for removing the background. Mostly intended for testing and evaluation.'),
 })
     .strict();
-export const robotImageBgremoveInstructionsWithHiddenFieldsSchema = robotImageBgremoveInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotImageBgremoveInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotImageBgremoveInstructionsSchema = interpolateRobot(robotImageBgremoveInstructionsSchema);
-export const interpolatableRobotImageBgremoveInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageBgremoveInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotImageBgremoveInstructionsSchema);
+export const { withHiddenFields: robotImageBgremoveInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageBgremoveInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageBgremoveInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/image-copyrightdetect.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 robotImageCopyrightdetectInstructionsSchema: 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";
@@ -38,26 +39,28 @@ export declare const robotImageCopyrightdetectInstructionsSchema: z.ZodObject<{
     categories: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         all: "all";
         artwork: "artwork";
+        watermarked: "watermarked";
         stock_photo: "stock_photo";
         brand_logo: "brand_logo";
-        watermarked: "watermarked";
     }>>>;
     error_on_decline: z.ZodDefault<z.ZodBoolean>;
     error_msg: z.ZodDefault<z.ZodString>;
     format: z.ZodDefault<z.ZodEnum<{
-        meta: "meta";
         json: "json";
+        meta: "meta";
     }>>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotImageCopyrightdetectInstructionsSchema.shape>;
 export declare const robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -85,35 +88,33 @@ export declare const robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema
     categories: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         all: "all";
         artwork: "artwork";
+        watermarked: "watermarked";
         stock_photo: "stock_photo";
         brand_logo: "brand_logo";
-        watermarked: "watermarked";
     }>>>;
     error_on_decline: z.ZodDefault<z.ZodBoolean>;
     error_msg: z.ZodDefault<z.ZodString>;
     format: z.ZodDefault<z.ZodEnum<{
-        meta: "meta";
         json: "json";
+        meta: "meta";
     }>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotImageCopyrightdetectInstructions = z.infer<typeof robotImageCopyrightdetectInstructionsSchema>;
-export type RobotImageCopyrightdetectInstructionsWithHiddenFields = z.infer<typeof robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotImageCopyrightdetectInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotImageCopyrightdetectInstructionsSchema: 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 interpolatableRobotImageCopyrightdetectInstructionsSchema:
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/copyrightdetect">;
-    confidence_threshold: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    categories: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    confidence_threshold: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    categories: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         all: "all";
         artwork: "artwork";
+        watermarked: "watermarked";
         stock_photo: "stock_photo";
         brand_logo: "brand_logo";
-        watermarked: "watermarked";
     }>]>>]>>;
-    error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    error_msg: z.ZodDefault<z.ZodString>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        meta: "meta";
+    error_on_decline: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    error_msg: z.ZodPrefault<z.ZodString>;
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         json: "json";
+        meta: "meta";
     }>]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotImageCopyrightdetectInstructions = InterpolatableRobotImageCopyrightdetectInstructionsInput;
-export type InterpolatableRobotImageCopyrightdetectInstructionsInput = z.input<typeof interpolatableRobotImageCopyrightdetectInstructionsSchema>;
-export declare const interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema: 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 interpolatableRobotImageCopyrightdetectInstructionsWithHidd
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/copyrightdetect">;
-    confidence_threshold: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    categories: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    confidence_threshold: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    categories: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         all: "all";
         artwork: "artwork";
+        watermarked: "watermarked";
         stock_photo: "stock_photo";
         brand_logo: "brand_logo";
-        watermarked: "watermarked";
     }>]>>]>>;
-    error_on_decline: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    error_msg: z.ZodDefault<z.ZodString>;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        meta: "meta";
+    error_on_decline: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    error_msg: z.ZodPrefault<z.ZodString>;
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         json: "json";
+        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 InterpolatableRobotImageCopyrightdetectInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotImageCopyrightdetectInstructions = Instructions['output'];
+export type RobotImageCopyrightdetectInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotImageCopyrightdetectInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageCopyrightdetectInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageCopyrightdetectInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=image-copyrightdetect.d.ts.map

package/dist/v4/robots/image-copyrightdetect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-copyrightdetect.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-copyrightdetect.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,cAyElB,CAAA;AAED,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqD7C,CAAA;AAEX,eAAO,MAAM,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKpE,CAAA;AAEJ,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAA;AACD,MAAM,MAAM,qDAAqD,GAAG,CAAC,CAAC,KAAK,CACzE,OAAO,2DAA2D,CACnE,CAAA;AAED,eAAO,MAAM,yDAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAErE,CAAA;AACD,MAAM,MAAM,mDAAmD,GAC7D,wDAAwD,CAAA;AAE1D,MAAM,MAAM,wDAAwD,GAAG,CAAC,CAAC,KAAK,CAC5E,OAAO,yDAAyD,CACjE,CAAA;AAED,eAAO,MAAM,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC/E,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,yEAAyE,CACjF,CAAA;AACD,MAAM,MAAM,wEAAwE,GAAG,CAAC,CAAC,KAAK,CAC5F,OAAO,yEAAyE,CACjF,CAAA"}
+{"version":3,"file":"image-copyrightdetect.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-copyrightdetect.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;AAU1B,eAAO,MAAM,IAAI,EAAE,cAsDlB,CAAA;AAED,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqD7C,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,2CAA2C,CAAC,KAAK,CACQ,CAAA;AAElE,eAAO,MACa,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC7D,yDAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEvE,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC1D,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,qCAAqC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAC1E,MAAM,MAAM,qDAAqD,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAChG,MAAM,MAAM,mDAAmD,GAC7D,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,wDAAwD,GAClE,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,mEAAmE,GAC7E,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,wEAAwE,GAClF,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,20 +1,12 @@
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobot, robotArtificialIntelligenceMeta, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            copyright_checked: {
-                robot: '/image/copyrightdetect',
-                use: ':original',
-                confidence_threshold: 80,
-                error_on_decline: true,
-                error_msg: 'This image appears to be a known stock photo. Please upload original content.',
-            },
-        },
-    },
+    ...robotArtificialIntelligenceMeta,
+    example_code: createProcessingExample('copyright_checked', '/image/copyrightdetect', {
+        confidence_threshold: 80,
+        error_on_decline: true,
+        error_msg: 'This image appears to be a known stock photo. Please upload original content.',
+    }),
     example_code_description: 'Detect known stock photos and copyrighted works in uploaded images and reject flagged files:',
     extended_description: `
 > [!Note]
@@ -50,26 +42,15 @@ export const meta = {
 >
 > In this setup, files with at least one match at or above your threshold are declined, and only the remaining files continue to later Steps.
 `,
-    minimum_charge: 1572864,
-    output_factor: 0.05,
     override_lvl1: 'Artificial Intelligence',
     purpose_sentence: 'detects known stock photos, brand logos, and watermarked images in uploaded files using reverse image search',
     purpose_verb: 'detect',
     purpose_word: 'detect stock photos and copyrighted works',
     purpose_words: 'Detect known stock photos and copyrighted works in images',
-    service_slug: 'artificial-intelligence',
-    slot_count: 10,
     title: 'Detect known stock photos and copyrighted works in images',
     typical_file_size_mb: 0.8,
-    typical_file_type: 'image',
     name: 'ImageCopyrightdetectRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsd: 0.0013,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
     stage: 'alpha',
 };
 export const robotImageCopyrightdetectInstructionsSchema = robotBase
@@ -126,10 +107,5 @@ In what format to return the detection results.
 `),
 })
     .strict();
-export const robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema = robotImageCopyrightdetectInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotImageCopyrightdetectInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotImageCopyrightdetectInstructionsSchema = interpolateRobot(robotImageCopyrightdetectInstructionsSchema);
-export const interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotImageCopyrightdetectInstructionsSchema);
+export const { withHiddenFields: robotImageCopyrightdetectInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageCopyrightdetectInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageCopyrightdetectInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/image-describe.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 robotImageDescribeInstructionsSchema: 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,30 +36,32 @@ export declare const robotImageDescribeInstructionsSchema: z.ZodObject<{
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/describe">;
     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";
     }>>;
     explicit_descriptions: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotImageDescribeInstructionsSchema.shape>;
 export declare const robotImageDescribeInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -83,39 +86,37 @@ export declare const robotImageDescribeInstructionsWithHiddenFieldsSchema: z.Zod
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/describe">;
     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";
     }>>;
     explicit_descriptions: z.ZodDefault<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotImageDescribeInstructions = z.infer<typeof robotImageDescribeInstructionsSchema>;
-export type RobotImageDescribeInstructionsWithHiddenFields = z.infer<typeof robotImageDescribeInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotImageDescribeInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotImageDescribeInstructionsSchema: 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")[]>>]>>;
@@ -134,38 +135,36 @@ export declare const interpolatableRobotImageDescribeInstructionsSchema: z.ZodOb
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/describe">;
-    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";
     }>]>>;
-    explicit_descriptions: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotImageDescribeInstructions = InterpolatableRobotImageDescribeInstructionsInput;
-export type InterpolatableRobotImageDescribeInstructionsInput = z.input<typeof interpolatableRobotImageDescribeInstructionsSchema>;
-export declare const interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    explicit_descriptions: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>, interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -184,23 +183,29 @@ export declare const interpolatableRobotImageDescribeInstructionsWithHiddenField
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/describe">;
-    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";
     }>]>>;
-    explicit_descriptions: 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]>>]>>;
+    explicit_descriptions: 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 InterpolatableRobotImageDescribeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotImageDescribeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotImageDescribeInstructions = Instructions['output'];
+export type RobotImageDescribeInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotImageDescribeInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageDescribeInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageDescribeInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotImageDescribeInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=image-describe.d.ts.map

package/dist/v4/robots/image-describe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-describe.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-describe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCtC,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":"image-describe.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-describe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAa1B,eAAO,MAAM,IAAI,EAAE,cAoBlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8BtC,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/image-describe.js

@@ -1,44 +1,24 @@
 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: {
-            described: {
-                robot: '/image/describe',
-                use: ':original',
-                provider: 'aws',
-            },
-        },
-    },
+    ...robotArtificialIntelligenceMeta,
+    example_code: createProcessingExample('described', '/image/describe', {
+        provider: 'aws',
+    }),
     example_code_description: 'Recognize objects in an uploaded image and store the labels in a JSON file:',
     extended_description: `
 > [!Warning]
 > Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses third-party AI services. The providers (AWS, GCP) will evolve their models over time, giving different responses for the same input images. Avoid relying on exact responses in your tests and application.
 `,
-    minimum_charge: 1572864,
-    output_factor: 0.05,
     override_lvl1: 'Artificial Intelligence',
     purpose_sentence: 'recognizes objects in images and returns them as English words',
     purpose_verb: 'recognize',
     purpose_word: 'recognize objects',
     purpose_words: 'Recognize objects in images',
-    service_slug: 'artificial-intelligence',
-    slot_count: 10,
     title: 'Recognize objects in images',
     typical_file_size_mb: 0.8,
-    typical_file_type: 'image',
     name: 'ImageDescribeRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsd: 0.0013,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotImageDescribeInstructionsSchema = robotBase
     .merge(robotUse)
@@ -46,11 +26,7 @@ export const robotImageDescribeInstructionsSchema = robotBase
     robot: z.literal('/image/describe').describe(`
 You can use the labels that we return in your application to automatically classify images. You can also pass the labels down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain content.
 `),
-    provider: awsGcpAiProviderSchema.describe(`
-${autoProviderDescription}
-
-Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
-`),
+    provider: awsGcpAiProviderSchema.describe(robotParameterDocs.ai_provider.description),
     granularity: granularitySchema.describe(`
 Whether to return a full response (\`"full"\`) including confidence percentages for each found label, or just a flat list of labels (\`"list"\`).
 `),
@@ -75,10 +51,5 @@ For an example of how to automatically reject NSFW content and malware, please c
 `),
 })
     .strict();
-export const robotImageDescribeInstructionsWithHiddenFieldsSchema = robotImageDescribeInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotImageDescribeInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotImageDescribeInstructionsSchema = interpolateRobot(robotImageDescribeInstructionsSchema);
-export const interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageDescribeInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotImageDescribeInstructionsSchema);
+export const { withHiddenFields: robotImageDescribeInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageDescribeInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageDescribeInstructionsWithHiddenFieldsSchema, } = robotDefinition;