@transloadit/zod 4.5.0 → 5.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"image-resize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-resize.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"image-resize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-resize.ts"],"names":[],"mappings":"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"}

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

@@ -1,42 +1,24 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
 import { imagemagickDensityPattern } from "../imagemagickDensity.js";
-import { color_without_alpha_with_named, colorspaceSchema, complexHeightSchema, complexWidthSchema, httpUrlSchema, imageQualitySchema, interpolateRobot, percentageSchema, positionSchema, robotBase, robotImagemagick, robotUse, unsafeCoordinatesSchema, } from "./_instructions-primitives.js";
+import { zodInputPreservingTransform } from "../lib/zodInputSemantics.js";
+import { color_without_alpha_with_named, colorspaceSchema, complexHeightSchema, complexWidthSchema, createProcessingExample, defineRobotWithHiddenFields, httpUrlSchema, imageAdaptiveFilteringSchema, imageQualitySchema, percentageSchema, positionSchema, robotBase, robotImagemagick, robotImageProcessingMeta, robotUse, unsafeCoordinatesSchema, } from "./_instructions-primitives.js";
 const imageResizeGravitySchema = z.union([positionSchema, z.enum(['attention', 'entropy'])]);
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            resized: {
-                robot: '/image/resize',
-                use: ':original',
-                width: 200,
-            },
-        },
-    },
+    ...robotImageProcessingMeta,
+    example_code: createProcessingExample('resized', '/image/resize', {
+        width: 200,
+    }),
     example_code_description: 'Resize uploaded images to a width of 200px while keeping their original aspect ratio:',
-    minimum_charge: 0,
-    output_factor: 0.6,
-    override_lvl1: 'Image Manipulation',
     purpose_sentence: 'resizes, crops, changes colorization, rotation, and applies text and watermarks to images',
     purpose_verb: 'convert',
     purpose_word: 'convert/resize/watermark',
     purpose_words: 'Convert, resize, or watermark images',
-    service_slug: 'image-manipulation',
-    slot_count: 5,
     title: 'Convert, resize, or watermark images',
-    typical_file_size_mb: 0.8,
-    typical_file_type: 'image',
     uses_tools: ['imagemagick'],
     name: 'ImageResizeRobot',
-    priceFactor: 1,
     queueSlotCount: 5,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const oneTextSchema = z.object({
     // TODO: Determine valid fonts
@@ -149,10 +131,10 @@ If \`null\` (default), then the input image's format will be used as the output
 
 If you wish to convert to \`"pdf"\`, please consider [🤖/document/convert](/docs/robots/document-convert/) instead.
 `),
-    width: complexWidthSchema.optional().describe(`
+    width: optionalWithV3Semantics(complexWidthSchema).describe(`
 Width of the result in pixels. If not specified, will default to the width of the original.
 `),
-    height: complexHeightSchema.optional().describe(`
+    height: optionalWithV3Semantics(complexHeightSchema).describe(`
 Height of the new image, in pixels. If not specified, will default to the height of the input image.
 `),
     resize_strategy: z
@@ -196,7 +178,7 @@ See the list of available [resize strategies](/docs/topics/resize-strategies/).
         .describe(`
 If this is set to \`false\`, smaller images will not be stretched to the desired width and height. For details about the impact of zooming for your preferred resize strategy, see the list of available [resize strategies](/docs/topics/resize-strategies/).
 `),
-    crop: unsafeCoordinatesSchema.optional().describe(`
+    crop: optionalWithV3Semantics(unsafeCoordinatesSchema).describe(`
 Specify an object containing coordinates for the top left and bottom right corners of the rectangle to be cropped from the original image(s). The coordinate system is rooted in the top left corner of the image. Values can be integers for absolute pixel values or strings for percentage based values.
 
 For example:
@@ -231,7 +213,7 @@ You can also use \`"entropy"\` or \`"attention"\` for automatic point-of-interes
         .describe(`
 Strips all metadata from the image. This is useful to keep thumbnails as small as possible.
 `),
-    alpha: z
+    alpha: optionalWithV3Semantics(z
         .enum([
         'Activate',
         'Background',
@@ -245,12 +227,11 @@ Strips all metadata from the image. This is useful to keep thumbnails as small a
         'Set',
         'Shape',
         'Transparent',
-    ])
-        .optional()
+    ]))
         .describe(`
 Gives control of the alpha/matte channel of an image.
 `),
-    preclip_alpha: z
+    preclip_alpha: optionalWithV3Semantics(z
         .enum([
         'Activate',
         'Background',
@@ -264,8 +245,7 @@ Gives control of the alpha/matte channel of an image.
         'Set',
         'Shape',
         'Transparent',
-    ])
-        .optional()
+    ]))
         .describe(`
 Gives control of the alpha/matte channel of an image before applying the clipping path via \`clip: true\`.
 `),
@@ -284,12 +264,7 @@ To preserve animations, GIF files are not flattened when this is set to \`true\`
 Prevents gamma errors [common in many image scaling algorithms](https://www.4p8.com/eric.brasseur/gamma.html).
 `),
     quality: imageQualitySchema,
-    adaptive_filtering: z
-        .boolean()
-        .default(false)
-        .describe(`
-Controls the image compression for PNG images. Setting to \`true\` results in smaller file size, while increasing processing time. It is encouraged to keep this option disabled.
-`),
+    adaptive_filtering: imageAdaptiveFilteringSchema,
     background: color_without_alpha_with_named.default('#FFFFFF').describe(`
 Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.php#color_names) of the color used to fill the background (used for the \`pad\` resize strategy).
 
@@ -304,10 +279,10 @@ Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.p
         .describe(`
 Use this parameter when dealing with animated GIF files to specify which frame of the GIF is used for the operation. Specify \`1\` to use the first frame, \`2\` to use the second, and so on. \`null\` means all frames.
 `),
-    colorspace: colorspaceSchema.optional().describe(`
+    colorspace: optionalWithV3Semantics(colorspaceSchema).describe(`
 Sets the image colorspace. For details about the available values, see the [ImageMagick documentation](https://www.imagemagick.org/script/command-line-options.php#colorspace). Please note that if you were using \`"RGB"\`, we recommend using \`"sRGB"\` instead as of 2014-02-04. ImageMagick might try to find the most efficient \`colorspace\` based on the color of an image, and default to e.g. \`"Gray"\`. To force colors, you might have to use this parameter in combination with \`type: "TrueColor"\`.
 `),
-    type: z
+    type: optionalWithV3Semantics(z
         .enum([
         'Bilevel',
         'ColorSeparation',
@@ -318,8 +293,7 @@ Sets the image colorspace. For details about the available values, see the [Imag
         'PaletteAlpha',
         'TrueColor',
         'TrueColorAlpha',
-    ])
-        .optional()
+    ]))
         .describe(`
 Sets the image color type. For details about the available values, see the [ImageMagick documentation](https://www.imagemagick.org/script/command-line-options.php#type). If you're using \`colorspace\`, ImageMagick might try to find the most efficient based on the color of an image, and default to e.g. \`"Gray"\`. To force colors, you could e.g. set this parameter to \`"TrueColor"\`
 `),
@@ -354,7 +328,7 @@ Please also take a look at [🤖/image/optimize](/docs/robots/image-optimize/).
 `),
     blur: z
         .string()
-        .regex(/^\d+(\.\d+)?x\d+(\.\d+)?$/)
+        .regex(/^[0-9]+(\.[0-9]+)?x[0-9]+(\.[0-9]+)?$/u)
         .nullable()
         .default(null)
         .describe(`
@@ -404,7 +378,7 @@ Changes the hue by rotating the color of the image. The value \`100\` would prod
         .describe(`
 Adjusts the contrast of the image. A value of \`1\` produces no change. Values below \`1\` decrease contrast (with \`0\` being minimum contrast), and values above \`1\` increase contrast (with \`2\` being maximum contrast). This works like the \`brightness\` parameter.
 `),
-    watermark_url: httpUrlSchema.optional().describe(`
+    watermark_url: optionalWithV3Semantics(httpUrlSchema).describe(`
 A URL indicating a PNG image to be overlaid above this image. Please note that you can also  [supply the watermark via another Assembly Step](/docs/topics/use-parameter/#supplying-the-watermark-via-an-assembly-step). With watermarking you can add an image onto another image. This is usually used for logos.
 `),
     watermark_position: z
@@ -435,7 +409,7 @@ The y-offset in number of pixels at which the watermark will be placed in relati
 
 Values can be both positive and negative and yield different results depending on the \`watermark_position\` parameter. Positive values move the watermark closer to the image's center point, whereas negative values move the watermark further away from the image's center point.
 `),
-    watermark_size: percentageSchema.optional().describe(`
+    watermark_size: optionalWithV3Semantics(percentageSchema).describe(`
 The size of the watermark, as a percentage.
 
 For example, a value of \`"50%"\` means that size of the watermark will be 50% of the size of image on which it is placed. The exact sizing depends on \`watermark_resize_strategy\`, too.
@@ -482,14 +456,13 @@ When set to \`true\`, the watermark will be repeated vertically across the entir
 
 This is useful for creating tiled watermark patterns that cover the full image. Can be combined with \`watermark_repeat_x\` to tile in both directions.
 `),
-    text: z
+    text: optionalWithV3Semantics(z
         .union([
         // Support single text object (backward compatibility)
         oneTextSchema,
         // Support array of text objects (current schema)
         z.array(oneTextSchema),
-    ])
-        .optional()
+    ]))
         .describe(TEXT_DESCRIPTION),
     progressive: z
         .boolean()
@@ -497,9 +470,8 @@ This is useful for creating tiled watermark patterns that cover the full image.
         .describe(`
 Interlaces the image if set to \`true\`, which makes the image load progressively in browsers. Instead of rendering the image from top to bottom, the browser will first show a low-res blurry version of the images which is then quickly replaced with the actual image as the data arrives. This greatly increases the user experience, but comes at a cost of a file size increase by around 10%.
 `),
-    transparent: z
-        .union([color_without_alpha_with_named, z.string().regex(/^\d+,\d+,\d+$/)])
-        .optional()
+    transparent: optionalWithV3Semantics(z
+        .union([color_without_alpha_with_named, z.string().regex(/^[0-9]+,[0-9]+,[0-9]+$/u)]))
         .describe(`
 Make this color transparent within the image. Example: \`"255,255,255"\`.
 `),
@@ -576,59 +548,50 @@ If your converted image is unsharp, please try increasing density.
         .describe(`
 Transform the image to black and white. This is a shortcut for setting the colorspace to Gray and type to Bilevel.
 `),
-    shave: z
+    shave: optionalWithV3Semantics(z
         .union([
-        z.string().regex(/^\d+(x\d+)?$/),
-        z.number().int().min(0).transform(String), // Accept numbers and convert to string
-    ])
-        .optional()
+        z.string().regex(/^[0-9]+(x[0-9]+)?$/u),
+        zodInputPreservingTransform(z.number().int().min(0), String),
+    ]))
         .describe(`
 Shave pixels from the image edges. The value should be in the format \`width\` or \`width\`x\`height\` to specify the number of pixels to remove from each side.
 `),
 })
     .strict();
-export const robotImageResizeInstructionsWithHiddenFieldsSchema = robotImageResizeInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotImageResizeInstructionsSchema.shape.result])
-        .optional(),
-    stack: z.string().optional().describe('Legacy parameter, use imagemagick_stack instead'),
-    text: z
+const hiddenFields = {
+    stack: optionalWithV3Semantics(z.string()).describe('Legacy parameter, use imagemagick_stack instead'),
+    text: optionalWithV3Semantics(z
         .union([
         // Support single text object (backward compatibility)
         oneTextSchema.extend({
-            gravity: positionSchema
-                .default('top-left')
-                .optional()
+            gravity: optionalWithV3Semantics(positionSchema
+                .default('top-left'))
                 .describe(`
             Legacy. The direction from which to start the offsets.
             `),
         }),
         // Support array of text objects (current schema)
         z.array(oneTextSchema.extend({
-            gravity: positionSchema
-                .default('top-left')
-                .optional()
+            gravity: optionalWithV3Semantics(positionSchema
+                .default('top-left'))
                 .describe(`
               Legacy. The direction from which to start the offsets.
               `),
         })),
-    ])
-        .optional()
+    ]))
         .describe(TEXT_DESCRIPTION),
-    watermark_position_x: z
+    watermark_position_x: optionalWithV3Semantics(z
         .number()
-        .int()
-        .optional()
+        .int())
         .describe(`
       Legacy alias for \`watermark_x_offset\`. The x-offset in number of pixels at which the watermark will be placed.
       `),
-    watermark_position_y: z
+    watermark_position_y: optionalWithV3Semantics(z
         .number()
-        .int()
-        .optional()
+        .int())
         .describe(`
       Legacy alias for \`watermark_y_offset\`. The y-offset in number of pixels at which the watermark will be placed.
       `),
-});
-export const interpolatableRobotImageResizeInstructionsSchema = interpolateRobot(robotImageResizeInstructionsSchema);
-export const interpolatableRobotImageResizeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageResizeInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotImageResizeInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotImageResizeInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageResizeInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageResizeInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/image-upscale.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotImageUpscaleInstructionsSchema: 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";
@@ -34,23 +35,28 @@ export declare const robotImageUpscaleInstructionsSchema: z.ZodObject<{
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/upscale">;
-    model: z.ZodOptional<z.ZodEnum<{
+    model: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
         "nightmareai/real-esrgan": "nightmareai/real-esrgan";
         "tencentarc/gfpgan": "tencentarc/gfpgan";
         "sczhou/codeformer": "sczhou/codeformer";
-    }>>;
-    scale: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
-    face_enhance: z.ZodOptional<z.ZodBoolean>;
+    }>>>;
+    scale: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<2>, z.ZodLiteral<4>]>>>;
+    face_enhance: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
 }, z.core.$strict>;
+declare const hiddenFields: {
+    provider: z.ZodDefault<z.ZodString>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotImageUpscaleInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotImageUpscaleInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -74,33 +80,31 @@ export declare const robotImageUpscaleInstructionsWithHiddenFieldsSchema: z.ZodO
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/upscale">;
-    model: z.ZodOptional<z.ZodEnum<{
+    model: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
         "nightmareai/real-esrgan": "nightmareai/real-esrgan";
         "tencentarc/gfpgan": "tencentarc/gfpgan";
         "sczhou/codeformer": "sczhou/codeformer";
-    }>>;
-    scale: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<2>, z.ZodLiteral<4>]>>;
-    face_enhance: z.ZodOptional<z.ZodBoolean>;
-    provider: z.ZodDefault<z.ZodString>;
+    }>>>;
+    scale: z.ZodOptional<z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<2>, z.ZodLiteral<4>]>>>;
+    face_enhance: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotImageUpscaleInstructions = z.infer<typeof robotImageUpscaleInstructionsSchema>;
-export type RobotImageUpscaleInstructionsWithHiddenFields = z.infer<typeof robotImageUpscaleInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotImageUpscaleInstructionsSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>, interpolatableRobotImageUpscaleInstructionsSchema: 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")[]>>]>>;
@@ -119,30 +123,28 @@ export declare const interpolatableRobotImageUpscaleInstructionsSchema: z.ZodObj
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/upscale">;
-    model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    model: z.ZodOptional<z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         "nightmareai/real-esrgan": "nightmareai/real-esrgan";
         "tencentarc/gfpgan": "tencentarc/gfpgan";
         "sczhou/codeformer": "sczhou/codeformer";
-    }>]>>;
-    scale: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<2>]>, z.ZodUnion<[z.ZodString, z.ZodLiteral<4>]>]>>;
-    face_enhance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotImageUpscaleInstructions = InterpolatableRobotImageUpscaleInstructionsInput;
-export type InterpolatableRobotImageUpscaleInstructionsInput = z.input<typeof interpolatableRobotImageUpscaleInstructionsSchema>;
-export declare const interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    }>]>>>;
+    scale: z.ZodOptional<z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<2>]>, z.ZodUnion<[z.ZodString, z.ZodLiteral<4>]>]>>>;
+    face_enhance: z.ZodOptional<z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>>;
+}, z.core.$strict>, interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -161,16 +163,22 @@ export declare const interpolatableRobotImageUpscaleInstructionsWithHiddenFields
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/upscale">;
-    model: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    model: z.ZodOptional<z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         "nightmareai/real-esrgan": "nightmareai/real-esrgan";
         "tencentarc/gfpgan": "tencentarc/gfpgan";
         "sczhou/codeformer": "sczhou/codeformer";
-    }>]>>;
-    scale: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<2>]>, z.ZodUnion<[z.ZodString, z.ZodLiteral<4>]>]>>;
-    face_enhance: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    provider: z.ZodDefault<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    }>]>>>;
+    scale: z.ZodOptional<z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<2>]>, z.ZodUnion<[z.ZodString, z.ZodLiteral<4>]>]>>>;
+    face_enhance: z.ZodOptional<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]>>]>>;
+    provider: z.ZodPrefault<z.ZodString>;
 }, z.core.$strict>;
-export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotImageUpscaleInstructions = Instructions['output'];
+export type RobotImageUpscaleInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotImageUpscaleInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageUpscaleInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotImageUpscaleInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=image-upscale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"image-upscale.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-upscale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM5D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,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-upscale.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-upscale.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAY1B,eAAO,MAAM,IAAI,EAAE,cAelB,CAAA;AAQD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgBrC,CAAA;AAEX,QAAA,MAAM,YAAY;;CAEjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,mCAAmC,CAAC,KAAK,EAChD,OAAO,YAAY,CACmE,CAAA;AAExF,eAAO,MACa,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACrD,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACjC,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAChF,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/v4/robots/image-upscale.js

@@ -1,64 +1,43 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { autoProviderDescription, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { imageUpscaleDefaultModelIdentifier, imageUpscaleModelIdentifiers } from "./_ai-models.js";
+import { autoProviderDescription, createProcessingExample, defineRobotWithHiddenFields, robotArtificialIntelligenceMeta, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            upscaled: {
-                robot: '/image/upscale',
-                use: ':original',
-                scale: 2,
-                face_enhance: true,
-            },
-        },
-    },
+    ...robotArtificialIntelligenceMeta,
+    example_code: createProcessingExample('upscaled', '/image/upscale', {
+        scale: 2,
+        face_enhance: true,
+    }),
     example_code_description: 'Upscale uploaded images and enhance faces:',
-    minimum_charge: 0,
-    output_factor: 0.6,
     purpose_sentence: 'upscales images using AI',
     purpose_verb: 'generate',
     purpose_word: 'upscale',
     purpose_words: 'Upscale images',
-    service_slug: 'artificial-intelligence',
-    slot_count: 10,
     title: 'Upscale images',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'image',
     name: 'ImageUpscaleRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsd: 0.06,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
     stage: 'beta',
 };
+const upscaleModelSchema = z
+    .enum(imageUpscaleModelIdentifiers)
+    .default(imageUpscaleDefaultModelIdentifier);
+const upscaleScaleSchema = z.union([z.literal(2), z.literal(4)]).default(2);
+const upscaleFaceEnhanceSchema = z.boolean().default(false);
 export const robotImageUpscaleInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/image/upscale'),
-    model: z
-        .enum(['nightmareai/real-esrgan', 'tencentarc/gfpgan', 'sczhou/codeformer'])
-        .optional()
-        .describe('The AI model to use for image upscaling. Defaults to nightmareai/real-esrgan.'),
-    scale: z
-        .union([z.literal(2), z.literal(4)])
-        .optional()
-        .describe('Upscale factor. Defaults to 2.'),
-    face_enhance: z
-        .boolean()
-        .optional()
-        .describe('Enable face enhancement for better face restoration. Defaults to false.'),
+    // Outer optional preserves parsed input; normalization applies the published inner defaults.
+    model: optionalWithV3Semantics(upscaleModelSchema)
+        .describe(`The AI model to use for image upscaling. Defaults to ${upscaleModelSchema.parse(undefined)}.`),
+    scale: optionalWithV3Semantics(upscaleScaleSchema)
+        .describe(`Upscale factor. Defaults to ${upscaleScaleSchema.parse(undefined)}.`),
+    face_enhance: optionalWithV3Semantics(upscaleFaceEnhanceSchema)
+        .describe(`Enable face enhancement for better face restoration. Defaults to ${upscaleFaceEnhanceSchema.parse(undefined)}.`),
 })
     .strict();
-export const robotImageUpscaleInstructionsWithHiddenFieldsSchema = robotImageUpscaleInstructionsSchema.extend({
+const hiddenFields = {
     provider: z.string().default('auto').describe(autoProviderDescription),
-    result: z
-        .union([z.literal('debug'), robotImageUpscaleInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotImageUpscaleInstructionsSchema = interpolateRobot(robotImageUpscaleInstructionsSchema);
-export const interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageUpscaleInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotImageUpscaleInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotImageUpscaleInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageUpscaleInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema, } = robotDefinition;