@transloadit/zod 4.5.0 → 5.0.1

package/dist/v3/robots/image-describe.js

@@ -1,44 +1,24 @@
 import { z } from 'zod/v3';
-import { autoProviderDescription, awsGcpAiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { awsGcpAiProviderSchema, createProcessingExample, defineRobot, granularitySchema, robotArtificialIntelligenceMeta, robotBase, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            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;

package/dist/v3/robots/image-enhance.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotImageEnhanceInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -69,19 +70,19 @@ export declare const robotImageEnhanceInstructionsSchema: z.ZodObject<{
     denoise: z.ZodDefault<z.ZodNumber>;
     quality: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    enhance: "none" | "auto" | "auto_gentle" | "auto_aggressive";
-    robot: "/image/enhance";
     result: boolean;
+    enhance: "auto" | "none" | "auto_gentle" | "auto_aggressive";
+    robot: "/image/enhance";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     preset: "none" | "cool" | "vivid" | "warm" | "vintage" | "matte" | "cinematic" | "golden_hour" | "bw_dramatic" | "bw_classic" | "noir" | "fade" | "pastel" | "teal_orange";
     imagemagick_stack: string;
-    engine: "classic" | "ai";
+    engine: "ai" | "classic";
     ai_preset: "restore" | "face_restore";
     sharpen: number;
     denoise: number;
     quality: number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -96,12 +97,13 @@ export declare const robotImageEnhanceInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
 }, {
     robot: "/image/enhance";
-    enhance?: "none" | "auto" | "auto_gentle" | "auto_aggressive" | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
+    enhance?: "auto" | "none" | "auto_gentle" | "auto_aggressive" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -116,22 +118,25 @@ export declare const robotImageEnhanceInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     preset?: "none" | "cool" | "vivid" | "warm" | "vintage" | "matte" | "cinematic" | "golden_hour" | "bw_dramatic" | "bw_classic" | "noir" | "fade" | "pastel" | "teal_orange" | undefined;
     imagemagick_stack?: string | undefined;
-    engine?: "classic" | "ai" | undefined;
+    engine?: "ai" | "classic" | undefined;
     ai_preset?: "restore" | "face_restore" | undefined;
     sharpen?: number | undefined;
     denoise?: number | undefined;
     quality?: number | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotImageEnhanceInstructionsSchema.shape>;
 export declare const robotImageEnhanceInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
@@ -195,18 +200,19 @@ export declare const robotImageEnhanceInstructionsWithHiddenFieldsSchema: z.ZodO
 } & {
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
-    enhance: "none" | "auto" | "auto_gentle" | "auto_aggressive";
+    enhance: "auto" | "none" | "auto_gentle" | "auto_aggressive";
     robot: "/image/enhance";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     preset: "none" | "cool" | "vivid" | "warm" | "vintage" | "matte" | "cinematic" | "golden_hour" | "bw_dramatic" | "bw_classic" | "noir" | "fade" | "pastel" | "teal_orange";
     imagemagick_stack: string;
-    engine: "classic" | "ai";
+    engine: "ai" | "classic";
     ai_preset: "restore" | "face_restore";
     sharpen: number;
     denoise: number;
     quality: number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -221,13 +227,13 @@ export declare const robotImageEnhanceInstructionsWithHiddenFieldsSchema: z.ZodO
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
 }, {
     robot: "/image/enhance";
-    enhance?: "none" | "auto" | "auto_gentle" | "auto_aggressive" | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
+    enhance?: "auto" | "none" | "auto_gentle" | "auto_aggressive" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -242,24 +248,23 @@ export declare const robotImageEnhanceInstructionsWithHiddenFieldsSchema: z.ZodO
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     preset?: "none" | "cool" | "vivid" | "warm" | "vintage" | "matte" | "cinematic" | "golden_hour" | "bw_dramatic" | "bw_classic" | "noir" | "fade" | "pastel" | "teal_orange" | undefined;
     imagemagick_stack?: string | undefined;
-    engine?: "classic" | "ai" | undefined;
+    engine?: "ai" | "classic" | undefined;
     ai_preset?: "restore" | "face_restore" | undefined;
     sharpen?: number | undefined;
     denoise?: number | undefined;
     quality?: number | undefined;
-}>;
-export type RobotImageEnhanceInstructions = z.infer<typeof robotImageEnhanceInstructionsSchema>;
-export type RobotImageEnhanceInstructionsWithHiddenFields = z.infer<typeof robotImageEnhanceInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotImageEnhanceInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotImageEnhanceInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -322,9 +327,10 @@ export declare const interpolatableRobotImageEnhanceInstructionsSchema: z.ZodObj
     denoise: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
+    result: string | boolean;
     enhance: string;
     robot: "/image/enhance";
-    result: string | boolean;
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     preset: string;
@@ -334,7 +340,6 @@ export declare const interpolatableRobotImageEnhanceInstructionsSchema: z.ZodObj
     sharpen: string | number;
     denoise: string | number;
     quality: string | number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -349,12 +354,13 @@ export declare const interpolatableRobotImageEnhanceInstructionsSchema: z.ZodObj
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
 }, {
     robot: "/image/enhance";
+    result?: string | boolean | undefined;
     enhance?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -369,8 +375,9 @@ export declare const interpolatableRobotImageEnhanceInstructionsSchema: z.ZodObj
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
@@ -381,12 +388,10 @@ export declare const interpolatableRobotImageEnhanceInstructionsSchema: z.ZodObj
     sharpen?: string | number | undefined;
     denoise?: string | number | undefined;
     quality?: string | number | undefined;
-}>;
-export type InterpolatableRobotImageEnhanceInstructions = InterpolatableRobotImageEnhanceInstructionsInput;
-export type InterpolatableRobotImageEnhanceInstructionsInput = z.input<typeof interpolatableRobotImageEnhanceInstructionsSchema>;
-export declare const interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
@@ -451,6 +456,7 @@ export declare const interpolatableRobotImageEnhanceInstructionsWithHiddenFields
 }, "strict", z.ZodTypeAny, {
     enhance: string;
     robot: "/image/enhance";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     preset: string;
@@ -460,7 +466,7 @@ export declare const interpolatableRobotImageEnhanceInstructionsWithHiddenFields
     sharpen: string | number;
     denoise: string | number;
     quality: string | number;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -475,13 +481,13 @@ export declare const interpolatableRobotImageEnhanceInstructionsWithHiddenFields
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
 }, {
     robot: "/image/enhance";
+    result?: string | boolean | undefined;
     enhance?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -496,8 +502,9 @@ export declare const interpolatableRobotImageEnhanceInstructionsWithHiddenFields
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
@@ -509,6 +516,12 @@ export declare const interpolatableRobotImageEnhanceInstructionsWithHiddenFields
     denoise?: string | number | undefined;
     quality?: string | number | undefined;
 }>;
-export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotImageEnhanceInstructions = Instructions['output'];
+export type RobotImageEnhanceInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotImageEnhanceInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageEnhanceInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=image-enhance.d.ts.map

package/dist/v3/robots/image-enhance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-enhance.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/image-enhance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cA0ClB,CAAA;AA2BD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwErC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"image-enhance.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/image-enhance.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;AAW1B,eAAO,MAAM,IAAI,EAAE,cA8BlB,CAAA;AA2BD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiErC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,mCAAmC,CAAC,KAAK,CACtC,CAAA;AAExD,eAAO,MACa,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACrD,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACjC,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAChF,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,6BAA6B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAClE,MAAM,MAAM,6CAA6C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACxF,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC7F,MAAM,MAAM,gDAAgD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAClG,MAAM,MAAM,2DAA2D,GACrE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,gEAAgE,GAC1E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v3/robots/image-enhance.js

@@ -1,9 +1,7 @@
 import { z } from 'zod/v3';
-import { imageQualitySchema, interpolateRobot, robotBase, robotImagemagick, robotUse, } from "./_instructions-primitives.js";
+import { defineRobot, imageQualitySchema, robotBase, robotImagemagick, robotImageProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
+    ...robotImageProcessingMeta,
     example_code: {
         steps: {
             enhanced_classic: {
@@ -21,26 +19,16 @@ export const meta = {
         },
     },
     example_code_description: 'Enhance uploaded images with classic auto mode or AI restoration:',
-    minimum_charge: 0,
-    output_factor: 0.6,
-    override_lvl1: 'Image Manipulation',
     purpose_sentence: 'automatically enhances images by adjusting levels, contrast, and sharpness, and optionally applies photo filter presets',
     purpose_verb: 'enhance',
     purpose_word: 'enhance',
     purpose_words: 'Enhance images',
-    service_slug: 'image-manipulation',
-    slot_count: 15,
     title: 'Enhance images',
     typical_file_size_mb: 1.2,
-    typical_file_type: 'image',
     name: 'ImageEnhanceRobot',
-    priceFactor: 1,
     queueSlotCount: 15,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'beta',
+    stage: 'ga',
 };
 const enhanceModeSchema = z.enum(['auto', 'auto_gentle', 'auto_aggressive', 'none']).default('auto');
 const presetSchema = z
@@ -72,14 +60,7 @@ With this <dfn>Robot</dfn> you can automatically enhance images with one click
 
 It works well together with [🤖/image/resize](/docs/robots/image-resize/) — you can enhance first, then resize, or vice versa.
 
-> [!Note]
-> This <dfn>Robot</dfn> accepts all image types supported by ImageMagick and will pass through unsupported types unchanged.
-
-> [!Note]
-> \`engine: "classic"\` uses \`enhance\`, \`preset\`, \`sharpen\`, and \`denoise\`. \`engine: "ai"\` uses \`ai_preset\` and \`quality\`; classic controls are ignored in AI mode.
-
-> [!Note]
-> Output keeps the original file extension when possible. In AI mode, if the target extension is not writable by the selected \`imagemagick_stack\`, the file is passed through unchanged.
+This <dfn>Robot</dfn> accepts all image types supported by ImageMagick and passes unsupported types through unchanged. \`engine: "classic"\` uses \`enhance\`, \`preset\`, \`sharpen\`, and \`denoise\`, while \`engine: "ai"\` uses \`ai_preset\` and \`quality\`; classic controls are ignored in AI mode. Output keeps the original file extension when possible. In AI mode, if the target extension is not writable by the selected \`imagemagick_stack\`, the file is passed through unchanged.
 `),
     enhance: enhanceModeSchema.describe(`
 The auto-enhancement mode. \`"auto"\` applies balanced auto-levels, gamma correction, and subtle sharpening. \`"auto_gentle"\` is more conservative (good for already-decent photos). \`"auto_aggressive"\` applies stronger normalization and contrast. \`"none"\` skips auto-enhance (useful when only applying a preset filter).
@@ -132,14 +113,9 @@ Additional sharpening amount (\`0\` = none, \`10\` = maximum). The \`"auto"\` en
 Noise reduction strength (\`0\` = none, \`10\` = maximum). Useful for high-ISO photos.
 `),
     quality: imageQualitySchema.describe(`
-Quality of the output image. A value between \`1\` and \`100\`. Defaults to \`92\`.
+Quality of the output image. A value between \`1\` and \`100\`. Defaults to \`${imageQualitySchema.parse(undefined)}\`.
 `),
 })
     .strict();
-export const robotImageEnhanceInstructionsWithHiddenFieldsSchema = robotImageEnhanceInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotImageEnhanceInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotImageEnhanceInstructionsSchema = interpolateRobot(robotImageEnhanceInstructionsSchema);
-export const interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageEnhanceInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotImageEnhanceInstructionsSchema);
+export const { withHiddenFields: robotImageEnhanceInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageEnhanceInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema, } = robotDefinition;