transloadit 4.7.4 → 4.8.0

package/dist/alphalib/types/robots/image-describe.js

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 import { aiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,

package/dist/alphalib/types/robots/image-describe.js.map

@@ -1 +1 @@
-{"version":3,"file":"image-describe.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-describe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,QAAQ,GACT,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,SAAS,EAAE;gBACT,KAAK,EAAE,iBAAiB;gBACxB,GAAG,EAAE,WAAW;gBAChB,QAAQ,EAAE,KAAK;aAChB;SACF;KACF;IACD,wBAAwB,EACtB,6EAA6E;IAC/E,oBAAoB,EAAE;;;CAGvB;IACC,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,yBAAyB;IACxC,gBAAgB,EAAE,gEAAgE;IAClF,YAAY,EAAE,WAAW;IACzB,YAAY,EAAE,mBAAmB;IACjC,aAAa,EAAE,6BAA6B;IAC5C,YAAY,EAAE,yBAAyB;IACvC,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,6BAA6B;IACpC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,OAAO;IAC1B,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,CAAC;IACd,cAAc,EAAE,EAAE;IAClB,gBAAgB,EAAE,MAAM;IACxB,wBAAwB,EAAE,IAAI;IAC9B,mBAAmB,EAAE,IAAI;IACzB,UAAU,EAAE,KAAK;IACjB,iDAAiD,EAAE,KAAK;IACxD,KAAK,EAAE,IAAI;CACZ,CAAA;AAED,MAAM,CAAC,MAAM,oCAAoC,GAAG,SAAS;KAC1D,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC;;CAEhD,CAAC;IACE,QAAQ,EAAE,gBAAgB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;;;CAIlD,CAAC;IACE,WAAW,EAAE,iBAAiB,CAAC,QAAQ,CAAC;;CAE3C,CAAC;IACE,MAAM,EAAE,CAAC;SACN,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;SAC9B,OAAO,CAAC,MAAM,CAAC;SACf,QAAQ,CAAC;;;;;CAKf,CAAC;IACE,qBAAqB,EAAE,CAAC;SACrB,OAAO,EAAE;SACT,OAAO,CAAC,KAAK,CAAC;SACd,QAAQ,CAAC;;;;;;CAMf,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,oDAAoD,GAC/D,oCAAoC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC;SACN,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,oCAAoC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC9E,QAAQ,EAAE;CACd,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,kDAAkD,GAAG,gBAAgB,CAChF,oCAAoC,CACrC,CAAA;AAQD,MAAM,CAAC,MAAM,kEAAkE,GAAG,gBAAgB,CAChG,oDAAoD,CACrD,CAAA"}
+{"version":3,"file":"image-describe.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-describe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,QAAQ,GACT,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,SAAS,EAAE;gBACT,KAAK,EAAE,iBAAiB;gBACxB,GAAG,EAAE,WAAW;gBAChB,QAAQ,EAAE,KAAK;aAChB;SACF;KACF;IACD,wBAAwB,EACtB,6EAA6E;IAC/E,oBAAoB,EAAE;;;CAGvB;IACC,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,yBAAyB;IACxC,gBAAgB,EAAE,gEAAgE;IAClF,YAAY,EAAE,WAAW;IACzB,YAAY,EAAE,mBAAmB;IACjC,aAAa,EAAE,6BAA6B;IAC5C,YAAY,EAAE,yBAAyB;IACvC,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,6BAA6B;IACpC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,OAAO;IAC1B,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,CAAC;IACd,cAAc,EAAE,EAAE;IAClB,gBAAgB,EAAE,MAAM;IACxB,wBAAwB,EAAE,IAAI;IAC9B,mBAAmB,EAAE,IAAI;IACzB,UAAU,EAAE,KAAK;IACjB,iDAAiD,EAAE,KAAK;IACxD,KAAK,EAAE,IAAI;CACZ,CAAA;AAED,MAAM,CAAC,MAAM,oCAAoC,GAAG,SAAS;KAC1D,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC;;CAEhD,CAAC;IACE,QAAQ,EAAE,gBAAgB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;;;CAIlD,CAAC;IACE,WAAW,EAAE,iBAAiB,CAAC,QAAQ,CAAC;;CAE3C,CAAC;IACE,MAAM,EAAE,CAAC;SACN,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;SAC9B,OAAO,CAAC,MAAM,CAAC;SACf,QAAQ,CAAC;;;;;CAKf,CAAC;IACE,qBAAqB,EAAE,CAAC;SACrB,OAAO,EAAE;SACT,OAAO,CAAC,KAAK,CAAC;SACd,QAAQ,CAAC;;;;;;CAMf,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,oDAAoD,GAC/D,oCAAoC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC;SACN,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,oCAAoC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC9E,QAAQ,EAAE;CACd,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,kDAAkD,GAAG,gBAAgB,CAChF,oCAAoC,CACrC,CAAA;AAQD,MAAM,CAAC,MAAM,kEAAkE,GAAG,gBAAgB,CAChG,oDAAoD,CACrD,CAAA"}

package/dist/alphalib/types/robots/image-enhance.d.ts

@@ -0,0 +1,502 @@
+import { z } from 'zod';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotImageEnhanceInstructionsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+    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")[]>>;
+} & {
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+} & {
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<[z.ZodEnum<["v3"]>, z.ZodString]>>;
+} & {
+    robot: z.ZodLiteral<"/image/enhance">;
+    enhance: z.ZodDefault<z.ZodEnum<["auto", "auto_gentle", "auto_aggressive", "none"]>>;
+    preset: z.ZodDefault<z.ZodEnum<["none", "warm", "cool", "vintage", "vivid", "matte", "cinematic", "golden_hour", "bw_dramatic", "bw_classic", "noir", "fade", "pastel", "teal_orange"]>>;
+    engine: z.ZodDefault<z.ZodEnum<["classic", "ai"]>>;
+    ai_preset: z.ZodDefault<z.ZodEnum<["restore", "face_restore"]>>;
+    sharpen: z.ZodDefault<z.ZodNumber>;
+    denoise: z.ZodDefault<z.ZodNumber>;
+    quality: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    result: boolean;
+    enhance: "auto" | "none" | "auto_gentle" | "auto_aggressive";
+    robot: "/image/enhance";
+    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";
+    ai_preset: "restore" | "face_restore";
+    sharpen: number;
+    denoise: number;
+    quality: number;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+}, {
+    robot: "/image/enhance";
+    result?: boolean | undefined;
+    enhance?: "auto" | "none" | "auto_gentle" | "auto_aggressive" | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | 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;
+    ai_preset?: "restore" | "face_restore" | undefined;
+    sharpen?: number | undefined;
+    denoise?: number | undefined;
+    quality?: number | undefined;
+}>;
+export declare const robotImageEnhanceInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    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")[]>>;
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<[z.ZodEnum<["v3"]>, z.ZodString]>>;
+    robot: z.ZodLiteral<"/image/enhance">;
+    enhance: z.ZodDefault<z.ZodEnum<["auto", "auto_gentle", "auto_aggressive", "none"]>>;
+    preset: z.ZodDefault<z.ZodEnum<["none", "warm", "cool", "vintage", "vivid", "matte", "cinematic", "golden_hour", "bw_dramatic", "bw_classic", "noir", "fade", "pastel", "teal_orange"]>>;
+    engine: z.ZodDefault<z.ZodEnum<["classic", "ai"]>>;
+    ai_preset: z.ZodDefault<z.ZodEnum<["restore", "face_restore"]>>;
+    sharpen: z.ZodDefault<z.ZodNumber>;
+    denoise: z.ZodDefault<z.ZodNumber>;
+    quality: z.ZodDefault<z.ZodNumber>;
+} & {
+    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, "strict", z.ZodTypeAny, {
+    enhance: "auto" | "none" | "auto_gentle" | "auto_aggressive";
+    robot: "/image/enhance";
+    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";
+    ai_preset: "restore" | "face_restore";
+    sharpen: number;
+    denoise: number;
+    quality: number;
+    result?: boolean | "debug" | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+}, {
+    robot: "/image/enhance";
+    result?: boolean | "debug" | undefined;
+    enhance?: "auto" | "none" | "auto_gentle" | "auto_aggressive" | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | 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;
+    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<{
+    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">]>]>>;
+    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]>>;
+    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")[]>]>>;
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<["v3"]>]>, z.ZodString]>>;
+    robot: z.ZodLiteral<"/image/enhance">;
+    enhance: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["auto", "auto_gentle", "auto_aggressive", "none"]>]>>;
+    preset: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["none", "warm", "cool", "vintage", "vivid", "matte", "cinematic", "golden_hour", "bw_dramatic", "bw_classic", "noir", "fade", "pastel", "teal_orange"]>]>>;
+    engine: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["classic", "ai"]>]>>;
+    ai_preset: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["restore", "face_restore"]>]>>;
+    sharpen: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    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";
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    preset: string;
+    imagemagick_stack: string;
+    engine: string;
+    ai_preset: string;
+    sharpen: string | number;
+    denoise: string | number;
+    quality: string | number;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+}, {
+    robot: "/image/enhance";
+    result?: string | boolean | undefined;
+    enhance?: string | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    preset?: string | undefined;
+    imagemagick_stack?: string | undefined;
+    engine?: string | undefined;
+    ai_preset?: string | undefined;
+    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<{
+    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">]>]>>;
+    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")[]>]>>;
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<["v3"]>]>, z.ZodString]>>;
+    robot: z.ZodLiteral<"/image/enhance">;
+    enhance: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["auto", "auto_gentle", "auto_aggressive", "none"]>]>>;
+    preset: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["none", "warm", "cool", "vintage", "vivid", "matte", "cinematic", "golden_hour", "bw_dramatic", "bw_classic", "noir", "fade", "pastel", "teal_orange"]>]>>;
+    engine: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["classic", "ai"]>]>>;
+    ai_preset: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["restore", "face_restore"]>]>>;
+    sharpen: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    denoise: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+}, "strict", z.ZodTypeAny, {
+    enhance: string;
+    robot: "/image/enhance";
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    preset: string;
+    imagemagick_stack: string;
+    engine: string;
+    ai_preset: string;
+    sharpen: string | number;
+    denoise: string | number;
+    quality: string | number;
+    result?: string | boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+}, {
+    robot: "/image/enhance";
+    result?: string | boolean | undefined;
+    enhance?: string | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        fields?: string[] | undefined;
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    preset?: string | undefined;
+    imagemagick_stack?: string | undefined;
+    engine?: string | undefined;
+    ai_preset?: string | undefined;
+    sharpen?: string | number | undefined;
+    denoise?: string | number | undefined;
+    quality?: string | number | undefined;
+}>;
+export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotImageEnhanceInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageEnhanceInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=image-enhance.d.ts.map

package/dist/alphalib/types/robots/image-enhance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-enhance.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-enhance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AASnE,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"}

package/dist/alphalib/types/robots/image-enhance.js

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import { imageQualitySchema, interpolateRobot, robotBase, robotImagemagick, robotUse, } from "./_instructions-primitives.js";
+export const meta = {
+    bytescount: 1,
+    discount_factor: 1,
+    discount_pct: 0,
+    example_code: {
+        steps: {
+            enhanced_classic: {
+                robot: '/image/enhance',
+                use: ':original',
+                enhance: 'auto',
+                preset: 'vivid',
+            },
+            enhanced_ai: {
+                robot: '/image/enhance',
+                use: ':original',
+                engine: 'ai',
+                ai_preset: 'restore',
+            },
+        },
+    },
+    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',
+};
+const enhanceModeSchema = z.enum(['auto', 'auto_gentle', 'auto_aggressive', 'none']).default('auto');
+const presetSchema = z
+    .enum([
+    'none',
+    'warm',
+    'cool',
+    'vintage',
+    'vivid',
+    'matte',
+    'cinematic',
+    'golden_hour',
+    'bw_dramatic',
+    'bw_classic',
+    'noir',
+    'fade',
+    'pastel',
+    'teal_orange',
+])
+    .default('none');
+const engineSchema = z.enum(['classic', 'ai']).default('classic');
+const aiPresetSchema = z.enum(['restore', 'face_restore']).default('restore');
+export const robotImageEnhanceInstructionsSchema = robotBase
+    .merge(robotUse)
+    .merge(robotImagemagick)
+    .extend({
+    robot: z.literal('/image/enhance').describe(`
+With this <dfn>Robot</dfn> you can automatically enhance images with one click — adjusting levels, contrast, saturation, sharpness, and white balance to produce an optimally balanced image. It also supports a library of named photo filter presets (e.g. \`warm\`, \`cool\`, \`vintage\`, \`vivid\`) that apply curated color grading and tone adjustments.
+
+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.
+`),
+    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).
+`),
+    preset: presetSchema.describe(`
+A named color grading preset to apply. Applied after auto-enhancement. Use \`"none"\` to skip preset application.
+
+Available presets:
+- \`warm\` — Warm golden tones
+- \`cool\` — Cool blue-shifted tones
+- \`vintage\` — Faded retro look with warm shadows
+- \`vivid\` — Boosted saturation and contrast
+- \`matte\` — Lifted blacks for a matte film look
+- \`cinematic\` — Teal-and-orange cinema grading
+- \`golden_hour\` — Warm sunset-like glow
+- \`bw_dramatic\` — High-contrast black and white
+- \`bw_classic\` — Classic film black and white
+- \`noir\` — Dark, moody black and white
+- \`fade\` — Washed-out faded look
+- \`pastel\` — Soft, desaturated pastel tones
+- \`teal_orange\` — Complementary teal shadows and orange highlights
+`),
+    engine: engineSchema.describe(`
+Enhancement engine to use.
+
+- \`"classic"\` uses ImageMagick-based adjustments and presets.
+- \`"ai"\` uses AI restoration models on Replicate (typically higher latency and cost than classic mode).
+`),
+    ai_preset: aiPresetSchema.describe(`
+AI enhancement preset used when \`engine\` is set to \`"ai"\`:
+- \`restore\` — General image restoration.
+- \`face_restore\` — Portrait-focused face restoration.
+
+AI mode is not intended for image upscaling. For dedicated upscaling, use [🤖/image/upscale](/docs/robots/image-upscale/).
+`),
+    sharpen: z
+        .number()
+        .min(0)
+        .max(10)
+        .default(0)
+        .describe(`
+Additional sharpening amount (\`0\` = none, \`10\` = maximum). The \`"auto"\` enhance mode already applies subtle sharpening; this parameter adds more on top.
+`),
+    denoise: z
+        .number()
+        .min(0)
+        .max(10)
+        .default(0)
+        .describe(`
+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\`.
+`),
+})
+    .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);
+//# sourceMappingURL=image-enhance.js.map