@transloadit/zod 4.4.1 → 5.0.0

package/dist/v3/robots/document-thumbs.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotDocumentThumbsInstructionsSchema: 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>;
@@ -78,8 +79,9 @@ export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
     pdf_use_cropbox: z.ZodDefault<z.ZodBoolean>;
     turbo: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/document/thumbs";
     result: boolean;
+    robot: "/document/thumbs";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     imagemagick_stack: string;
@@ -93,7 +95,6 @@ export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
     trim_whitespace: boolean;
     pdf_use_cropbox: boolean;
     alpha?: "Remove" | "Set" | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -108,6 +109,7 @@ export declare const robotDocumentThumbsInstructionsSchema: 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;
     width?: number | undefined;
@@ -118,8 +120,8 @@ export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
     colorspace?: "CMY" | "CMYK" | "Gray" | "HCL" | "HCLp" | "HSB" | "HSI" | "HSL" | "HSV" | "HWB" | "Jzazbz" | "Lab" | "LCHab" | "LCHuv" | "LMS" | "Log" | "Luv" | "OHTA" | "OkLab" | "OkLCH" | "Rec601YCbCr" | "Rec709YCbCr" | "RGB" | "scRGB" | "sRGB" | "Transparent" | "Undefined" | "xyY" | "XYZ" | "YCbCr" | "YCC" | "YDbDr" | "YIQ" | "YPbPr" | "YUV" | undefined;
 }, {
     robot: "/document/thumbs";
+    result?: boolean | undefined;
     alpha?: "Remove" | "Set" | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -134,8 +136,9 @@ export declare const robotDocumentThumbsInstructionsSchema: 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;
@@ -156,9 +159,17 @@ export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
     trim_whitespace?: boolean | undefined;
     pdf_use_cropbox?: boolean | undefined;
 }>;
+declare const hiddenFields: {
+    stack: z.ZodOptional<z.ZodEnum<["ghostscript", "vips", "pdfium", "imagemagick"]>>;
+    alpha: z.ZodOptional<z.ZodEnum<["Remove", "Set", "remove", "set"]>>;
+    resize_strategy: z.ZodOptional<z.ZodEnum<["crop", "fillcrop", "fit", "min_fit", "pad", "stretch", "none"]>>;
+    density: z.ZodOptional<z.ZodString>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotDocumentThumbsInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: 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")[]>>;
@@ -219,7 +230,6 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
     background: z.ZodDefault<z.ZodString>;
-    density: z.ZodOptional<z.ZodString>;
     antialiasing: z.ZodDefault<z.ZodBoolean>;
     colorspace: z.ZodOptional<z.ZodEnum<["CMY", "CMYK", "Gray", "HCL", "HCLp", "HSB", "HSI", "HSL", "HSV", "HWB", "Jzazbz", "Lab", "LCHab", "LCHuv", "LMS", "Log", "Luv", "OHTA", "OkLab", "OkLCH", "Rec601YCbCr", "Rec709YCbCr", "RGB", "scRGB", "sRGB", "Transparent", "Undefined", "xyY", "XYZ", "YCbCr", "YCC", "YDbDr", "YIQ", "YPbPr", "YUV"]>>;
     trim_whitespace: z.ZodDefault<z.ZodBoolean>;
@@ -230,8 +240,10 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
     stack: z.ZodOptional<z.ZodEnum<["ghostscript", "vips", "pdfium", "imagemagick"]>>;
     alpha: z.ZodOptional<z.ZodEnum<["Remove", "Set", "remove", "set"]>>;
     resize_strategy: z.ZodOptional<z.ZodEnum<["crop", "fillcrop", "fit", "min_fit", "pad", "stretch", "none"]>>;
+    density: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     robot: "/document/thumbs";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     imagemagick_stack: string;
@@ -243,8 +255,8 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
     page_range: string | null;
     trim_whitespace: boolean;
     pdf_use_cropbox: boolean;
+    result?: boolean | "debug" | undefined;
     alpha?: "set" | "remove" | "Remove" | "Set" | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -259,20 +271,20 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
         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;
     width?: number | undefined;
     height?: number | undefined;
-    resize_strategy?: "none" | "crop" | "fit" | "fillcrop" | "min_fit" | "pad" | "stretch" | undefined;
+    resize_strategy?: "crop" | "fit" | "fillcrop" | "min_fit" | "pad" | "stretch" | "none" | undefined;
     delay?: number | undefined;
     stack?: "imagemagick" | "ghostscript" | "vips" | "pdfium" | undefined;
     density?: string | undefined;
     colorspace?: "CMY" | "CMYK" | "Gray" | "HCL" | "HCLp" | "HSB" | "HSI" | "HSL" | "HSV" | "HWB" | "Jzazbz" | "Lab" | "LCHab" | "LCHuv" | "LMS" | "Log" | "Luv" | "OHTA" | "OkLab" | "OkLCH" | "Rec601YCbCr" | "Rec709YCbCr" | "RGB" | "scRGB" | "sRGB" | "Transparent" | "Undefined" | "xyY" | "XYZ" | "YCbCr" | "YCC" | "YDbDr" | "YIQ" | "YPbPr" | "YUV" | undefined;
 }, {
     robot: "/document/thumbs";
+    result?: boolean | "debug" | undefined;
     alpha?: "set" | "remove" | "Remove" | "Set" | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -287,15 +299,16 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
         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;
     width?: number | undefined;
     height?: number | undefined;
     imagemagick_stack?: string | undefined;
-    resize_strategy?: "none" | "crop" | "fit" | "fillcrop" | "min_fit" | "pad" | "stretch" | undefined;
+    resize_strategy?: "crop" | "fit" | "fillcrop" | "min_fit" | "pad" | "stretch" | "none" | undefined;
     background?: string | undefined;
     turbo?: boolean | undefined;
     format?: "gif" | "jpeg" | "jpg" | "png" | undefined;
@@ -308,12 +321,10 @@ export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.Zo
     colorspace?: "CMY" | "CMYK" | "Gray" | "HCL" | "HCLp" | "HSB" | "HSI" | "HSL" | "HSV" | "HWB" | "Jzazbz" | "Lab" | "LCHab" | "LCHuv" | "LMS" | "Log" | "Luv" | "OHTA" | "OkLab" | "OkLCH" | "Rec601YCbCr" | "Rec709YCbCr" | "RGB" | "scRGB" | "sRGB" | "Transparent" | "Undefined" | "xyY" | "XYZ" | "YCbCr" | "YCC" | "YDbDr" | "YIQ" | "YPbPr" | "YUV" | undefined;
     trim_whitespace?: boolean | undefined;
     pdf_use_cropbox?: boolean | undefined;
-}>;
-export type RobotDocumentThumbsInstructions = z.infer<typeof robotDocumentThumbsInstructionsSchema>;
-export type RobotDocumentThumbsInstructionsWithHiddenFields = z.infer<typeof robotDocumentThumbsInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDocumentThumbsInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotDocumentThumbsInstructionsSchema: 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]>>;
@@ -385,8 +396,9 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
     pdf_use_cropbox: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     turbo: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/document/thumbs";
     result: string | boolean;
+    robot: "/document/thumbs";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     imagemagick_stack: string;
@@ -400,7 +412,6 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
     trim_whitespace: string | boolean;
     pdf_use_cropbox: string | boolean;
     alpha?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -415,6 +426,7 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
         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;
     width?: string | number | undefined;
@@ -425,8 +437,8 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
     colorspace?: string | undefined;
 }, {
     robot: "/document/thumbs";
+    result?: string | boolean | undefined;
     alpha?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -441,8 +453,9 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
         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;
@@ -462,12 +475,10 @@ export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodO
     colorspace?: string | undefined;
     trim_whitespace?: string | boolean | undefined;
     pdf_use_cropbox?: string | boolean | undefined;
-}>;
-export type InterpolatableRobotDocumentThumbsInstructions = InterpolatableRobotDocumentThumbsInstructionsInput;
-export type InterpolatableRobotDocumentThumbsInstructionsInput = z.input<typeof interpolatableRobotDocumentThumbsInstructionsSchema>;
-export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema: 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")[]>]>>;
@@ -528,7 +539,6 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     background: z.ZodDefault<z.ZodString>;
-    density: z.ZodOptional<z.ZodString>;
     antialiasing: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     colorspace: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["CMY", "CMYK", "Gray", "HCL", "HCLp", "HSB", "HSI", "HSL", "HSV", "HWB", "Jzazbz", "Lab", "LCHab", "LCHuv", "LMS", "Log", "Luv", "OHTA", "OkLab", "OkLCH", "Rec601YCbCr", "Rec709YCbCr", "RGB", "scRGB", "sRGB", "Transparent", "Undefined", "xyY", "XYZ", "YCbCr", "YCC", "YDbDr", "YIQ", "YPbPr", "YUV"]>]>>;
     trim_whitespace: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -538,8 +548,10 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
     stack: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["ghostscript", "vips", "pdfium", "imagemagick"]>]>>;
     alpha: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["Remove", "Set", "remove", "set"]>]>>;
     resize_strategy: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["crop", "fillcrop", "fit", "min_fit", "pad", "stretch", "none"]>]>>;
+    density: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     robot: "/document/thumbs";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     imagemagick_stack: string;
@@ -551,8 +563,8 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
     page_range: string | null;
     trim_whitespace: string | boolean;
     pdf_use_cropbox: string | boolean;
+    result?: string | boolean | undefined;
     alpha?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -567,8 +579,8 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
         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;
     width?: string | number | undefined;
     height?: string | number | undefined;
@@ -579,8 +591,8 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
     colorspace?: string | undefined;
 }, {
     robot: "/document/thumbs";
+    result?: string | boolean | undefined;
     alpha?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -595,8 +607,9 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
         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;
@@ -617,6 +630,12 @@ export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFiel
     trim_whitespace?: string | boolean | undefined;
     pdf_use_cropbox?: string | boolean | undefined;
 }>;
-export type InterpolatableRobotDocumentThumbsInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDocumentThumbsInstructions = Instructions['output'];
+export type RobotDocumentThumbsInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDocumentThumbsInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentThumbsInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDocumentThumbsInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=document-thumbs.d.ts.map

package/dist/v3/robots/document-thumbs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-thumbs.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/document-thumbs.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,cAuClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkKvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB9D,CAAA;AAEJ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AACnG,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/D,CAAA;AACD,MAAM,MAAM,6CAA6C,GACvD,kDAAkD,CAAA;AAEpD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/E,CAAA;AACD,MAAM,MAAM,6DAA6D,GAAG,CAAC,CAAC,KAAK,CACjF,OAAO,mEAAmE,CAC3E,CAAA;AACD,MAAM,MAAM,kEAAkE,GAAG,CAAC,CAAC,KAAK,CACtF,OAAO,mEAAmE,CAC3E,CAAA"}
+{"version":3,"file":"document-thumbs.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/document-thumbs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAe1B,eAAO,MAAM,IAAI,EAAE,cAyBlB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuKvC,CAAA;AAEX,QAAA,MAAM,YAAY;;;;;CA0BjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,qCAAqC,CAAC,KAAK,EAClD,OAAO,YAAY,CACqE,CAAA;AAE1F,eAAO,MACa,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACvD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEjE,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACpD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,+BAA+B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACpE,MAAM,MAAM,+CAA+C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAC1F,MAAM,MAAM,6CAA6C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC/F,MAAM,MAAM,kDAAkD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACpG,MAAM,MAAM,6DAA6D,GACvE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,kEAAkE,GAC5E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v3/robots/document-thumbs.js

@@ -1,9 +1,10 @@
 import { z } from 'zod/v3';
-import { colorspaceSchema, interpolateRobot, robotBase, robotImagemagick, robotUse, } from "./_instructions-primitives.js";
+import { imagemagickDensityPattern } from "../imagemagickDensity.js";
+import { zodWithConservativeJsonInputSchema } from "../lib/zodInputSemantics.js";
+import { colorspaceSchema, defineRobotWithHiddenFields, robotBase, robotDocumentProcessingMeta, robotImagemagick, robotUse, } from "./_instructions-primitives.js";
+const documentThumbsPageRangeWireSchema = z.string().regex(/^[0-9]+-[0-9]+$/u);
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
+    ...robotDocumentProcessingMeta,
     example_code: {
         steps: {
             thumbnailed: {
@@ -16,28 +17,16 @@ export const meta = {
         },
     },
     example_code_description: 'Convert all pages of a PDF document into separate 200px-wide images:',
-    minimum_charge: 524288,
-    output_factor: 1,
-    override_lvl1: 'Document Processing',
     purpose_sentence: 'generates an image for each page in a PDF file or an animated GIF file that loops through all pages',
     purpose_verb: 'extract',
     purpose_word: 'thumbnail',
     purpose_words: 'Extract thumbnail images from documents',
-    service_slug: 'document-processing',
-    slot_count: 10,
     title: 'Extract thumbnail images from documents',
-    typical_file_size_mb: 0.8,
-    typical_file_type: 'document',
     uses_tools: ['imagemagick'],
     name: 'DocumentThumbsRobot',
-    priceFactor: 1,
     queueSlotCount: 60,
     minimumCharge: 524288,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotDocumentThumbsInstructionsSchema = robotBase
     .merge(robotUse)
@@ -57,18 +46,20 @@ export const robotDocumentThumbsInstructionsSchema = robotBase
         .describe(`
 The PDF page that you want to convert to an image. By default the value is \`null\` which means that all pages will be converted into images.
 `),
-    page_range: z
-        .string()
-        .regex(/^\d+-\d+$/)
-        .refine((val) => {
+    page_range: zodWithConservativeJsonInputSchema(documentThumbsPageRangeWireSchema.refine((val) => {
         const [start, end] = val.split('-').map(Number);
         return start >= 1 && end >= start;
-    }, { message: 'Start must be ≥ 1 and end must be ≥ start (e.g. "1-20")' })
+    }, {
+        message: 'Start must be ≥ 1 and end must be ≥ start (e.g. "1-20")',
+        params: { schemaRule: 'page-range-order' },
+    }), documentThumbsPageRangeWireSchema)
         .nullable()
         .default(null)
         .describe(`
 A page range to extract, in the format \`"start-end"\` (e.g., \`"1-20"\`). Extraction starts from the first page in the range and proceeds sequentially, stopping gracefully when a page does not exist. This is useful for PDFs where the total page count cannot be determined.
 
+The start must be at least \`1\`, and the end must be greater than or equal to the start.
+
 This parameter cannot be used together with \`page\`, and is not supported with GIF format. When \`page_range\` is set, the robot does not need to know the total page count upfront, making it robust for PDFs that fail page count detection.
 `),
     format: z
@@ -134,7 +125,7 @@ One of the [available resize strategies](/docs/topics/resize-strategies/).
         .describe(`
 Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.php#color_names) of the color used to fill the background (only used for the pad resize strategy).
 
-By default, the background of transparent images is changed to white. For details about how to preserve transparency across all image types, see [this demo](/demos/image-manipulation/properly-preserve-transparency-across-all-image-types/).
+By default, the background of transparent images is changed to white. For details about how to preserve transparency across all image types, see [this demo](/demos/image-processing/properly-preserve-transparency-across-all-image-types/).
 `),
     // TODO: Update options list. Why are they capitalized? They are lowercase in th ImageMagick docs.
     alpha: z
@@ -147,7 +138,7 @@ For a list of all valid values please check the ImageMagick documentation [here]
 `),
     density: z
         .string()
-        .regex(/\d+(x\d+)?/)
+        .regex(imagemagickDensityPattern)
         .optional()
         .describe(`
 While in-memory quality and file format depth specifies the color resolution, the density of an image is the spatial (space) resolution of the image. That is the density (in pixels per inch) of an image and defines how far apart (or how big) the individual pixels are. It defines the size of the image in real world terms when displayed on devices or printed.
@@ -199,10 +190,7 @@ Turbo Mode increases pricing in that the input document's file size is added for
 `),
 })
     .strict();
-export const robotDocumentThumbsInstructionsWithHiddenFieldsSchema = robotDocumentThumbsInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotDocumentThumbsInstructionsSchema.shape.result])
-        .optional(),
+const hiddenFields = {
     stack: z
         .enum(['ghostscript', 'vips', 'pdfium', 'imagemagick'])
         .optional()
@@ -221,8 +209,13 @@ Change how the alpha channel of the resulting image should work. Valid values ar
         .enum(['crop', 'fillcrop', 'fit', 'min_fit', 'pad', 'stretch', 'none'])
         .optional()
         .describe(`
-One of the [available resize strategies](/docs/transcoding/image-manipulation/image-resize/#resize-strategies). The 'none' value is supported for backwards compatibility.
+One of the [available resize strategies](/docs/robots/image-resize/#resize-strategies). The 'none' value is supported for backwards compatibility.
 `),
-});
-export const interpolatableRobotDocumentThumbsInstructionsSchema = interpolateRobot(robotDocumentThumbsInstructionsSchema);
-export const interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentThumbsInstructionsWithHiddenFieldsSchema);
+    // Match API2's compatibility boundary for persisted Templates without widening public input.
+    density: z
+        .string()
+        .regex(/[0-9]+(?:x[0-9]+)?/u)
+        .optional(),
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotDocumentThumbsInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotDocumentThumbsInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotDocumentThumbsInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v3/robots/dropbox-import.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 robotDropboxImportInstructionsSchema: 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>;
@@ -20,8 +21,9 @@ export declare const robotDropboxImportInstructionsSchema: z.ZodObject<{
     path: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/dropbox/import";
     result: boolean;
+    robot: "/dropbox/import";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
@@ -35,9 +37,10 @@ export declare const robotDropboxImportInstructionsSchema: z.ZodObject<{
 }, {
     path: string | string[];
     robot: "/dropbox/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -47,9 +50,11 @@ export declare const robotDropboxImportInstructionsSchema: z.ZodObject<{
     access_token?: string | undefined;
     refresh_token?: string | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotDropboxImportInstructionsSchema.shape>;
 export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: 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>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
@@ -65,13 +70,14 @@ export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: z.Zod
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/dropbox/import";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
+    result?: boolean | "debug" | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
     access_token?: string | undefined;
@@ -79,9 +85,10 @@ export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: z.Zod
 }, {
     path: string | string[];
     robot: "/dropbox/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -90,12 +97,10 @@ export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: z.Zod
     credentials?: string | undefined;
     access_token?: string | undefined;
     refresh_token?: string | undefined;
-}>;
-export type RobotDropboxImportInstructions = z.infer<typeof robotDropboxImportInstructionsSchema>;
-export type RobotDropboxImportInstructionsWithHiddenFields = z.infer<typeof robotDropboxImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDropboxImportInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotDropboxImportInstructionsSchema: 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]>>;
@@ -109,8 +114,9 @@ export declare const interpolatableRobotDropboxImportInstructionsSchema: z.ZodOb
     path: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/dropbox/import";
     result: string | boolean;
+    robot: "/dropbox/import";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
@@ -124,9 +130,10 @@ export declare const interpolatableRobotDropboxImportInstructionsSchema: z.ZodOb
 }, {
     path: string | string[];
     robot: "/dropbox/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -135,12 +142,10 @@ export declare const interpolatableRobotDropboxImportInstructionsSchema: z.ZodOb
     credentials?: string | undefined;
     access_token?: string | undefined;
     refresh_token?: string | undefined;
-}>;
-export type InterpolatableRobotDropboxImportInstructions = InterpolatableRobotDropboxImportInstructionsInput;
-export type InterpolatableRobotDropboxImportInstructionsInput = z.input<typeof interpolatableRobotDropboxImportInstructionsSchema>;
-export declare const interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema: 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]>>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
@@ -155,13 +160,14 @@ export declare const interpolatableRobotDropboxImportInstructionsWithHiddenField
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/dropbox/import";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
+    result?: string | boolean | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
     access_token?: string | undefined;
@@ -169,9 +175,10 @@ export declare const interpolatableRobotDropboxImportInstructionsWithHiddenField
 }, {
     path: string | string[];
     robot: "/dropbox/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -181,6 +188,12 @@ export declare const interpolatableRobotDropboxImportInstructionsWithHiddenField
     access_token?: string | undefined;
     refresh_token?: string | undefined;
 }>;
-export type InterpolatableRobotDropboxImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDropboxImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDropboxImportInstructions = Instructions['output'];
+export type RobotDropboxImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDropboxImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDropboxImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDropboxImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDropboxImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=dropbox-import.d.ts.map

package/dist/v3/robots/dropbox-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropbox-import.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/dropbox-import.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,cAqClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"dropbox-import.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/dropbox-import.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;AAY1B,eAAO,MAAM,IAAI,EAAE,cAYlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BtC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,oCAAoC,CAAC,KAAK,CACtC,CAAA;AAEzD,eAAO,MACa,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACtD,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEhE,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACnD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,8BAA8B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACnE,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,iDAAiD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACnG,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,iEAAiE,GAC3E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}