@transloadit/node 4.10.2 → 4.10.3

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

@@ -1 +1 @@
-{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageOcrInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -69,6 +70,7 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
     format: "json" | "text" | "meta";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
     granularity: "full" | "list";
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -88,6 +90,7 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
 }, {
     robot: "/image/ocr";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -111,6 +114,7 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
     granularity?: "full" | "list" | undefined;
 }>;
 export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -176,6 +180,7 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
     format: "json" | "text" | "meta";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
     granularity: "full" | "list";
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -196,6 +201,7 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
 }, {
     robot: "/image/ocr";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -221,6 +227,7 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
 export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>;
 export type RobotImageOcrInstructionsWithHiddenFields = z.infer<typeof robotImageOcrInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageOcrInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -286,6 +293,7 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
     format: string;
     provider: string;
     granularity: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -305,6 +313,7 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
 }, {
     robot: "/image/ocr";
     provider: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -330,6 +339,7 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
 export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
 export type InterpolatableRobotImageOcrInstructionsInput = z.input<typeof interpolatableRobotImageOcrInstructionsSchema>;
 export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -394,6 +404,7 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
     format: string;
     provider: string;
     granularity: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -414,6 +425,7 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
 }, {
     robot: "/image/ocr";
     provider: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-ocr.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,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}
+{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-ocr.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,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageOptimizeInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -73,6 +74,7 @@ export declare const robotImageOptimizeInstructionsSchema: z.ZodObject<{
     preserve_meta_data: boolean;
     fix_breaking_images: boolean;
     lossy: boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -91,6 +93,7 @@ export declare const robotImageOptimizeInstructionsSchema: z.ZodObject<{
     queue?: "batch" | undefined;
 }, {
     robot: "/image/optimize";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -117,6 +120,7 @@ export declare const robotImageOptimizeInstructionsSchema: z.ZodObject<{
     lossy?: boolean | undefined;
 }>;
 export declare const robotImageOptimizeInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -186,6 +190,7 @@ export declare const robotImageOptimizeInstructionsWithHiddenFieldsSchema: z.Zod
     preserve_meta_data: boolean;
     fix_breaking_images: boolean;
     lossy: boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -205,6 +210,7 @@ export declare const robotImageOptimizeInstructionsWithHiddenFieldsSchema: z.Zod
     queue?: "batch" | undefined;
 }, {
     robot: "/image/optimize";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -233,6 +239,7 @@ export declare const robotImageOptimizeInstructionsWithHiddenFieldsSchema: z.Zod
 export type RobotImageOptimizeInstructions = z.infer<typeof robotImageOptimizeInstructionsSchema>;
 export type RobotImageOptimizeInstructionsWithHiddenFields = z.infer<typeof robotImageOptimizeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageOptimizeInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -302,6 +309,7 @@ export declare const interpolatableRobotImageOptimizeInstructionsSchema: z.ZodOb
     preserve_meta_data: string | boolean;
     fix_breaking_images: string | boolean;
     lossy: string | boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -320,6 +328,7 @@ export declare const interpolatableRobotImageOptimizeInstructionsSchema: z.ZodOb
     queue?: string | undefined;
 }, {
     robot: "/image/optimize";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -348,6 +357,7 @@ export declare const interpolatableRobotImageOptimizeInstructionsSchema: z.ZodOb
 export type InterpolatableRobotImageOptimizeInstructions = InterpolatableRobotImageOptimizeInstructionsInput;
 export type InterpolatableRobotImageOptimizeInstructionsInput = z.input<typeof interpolatableRobotImageOptimizeInstructionsSchema>;
 export declare const interpolatableRobotImageOptimizeInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -416,6 +426,7 @@ export declare const interpolatableRobotImageOptimizeInstructionsWithHiddenField
     preserve_meta_data: string | boolean;
     fix_breaking_images: string | boolean;
     lossy: string | boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -435,6 +446,7 @@ export declare const interpolatableRobotImageOptimizeInstructionsWithHiddenField
     queue?: string | undefined;
 }, {
     robot: "/image/optimize";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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

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

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

@@ -45,7 +45,7 @@ This <dfn>Robot</dfn> enables you to lower your storage and bandwidth costs, and
 It works well together with [🤖/image/resize](/docs/robots/image-resize/) to bring the full power of resized and optimized images to your website or app.
 
 > [!Note]
-> This <dfn>Robot</dfn> accepts all image types and will just pass on unsupported image types unoptimized. Hence, there is no need to set up [🤖/file/filter](/docs/robots/file-filter/) workflows for this.
+> This <dfn>Robot</dfn> accepts all image types and will just pass on unsupported image types unoptimized, including JPEG XL (\`.jxl\`) images when no smaller optimized result can be produced. Hence, there is no need to set up [🤖/file/filter](/docs/robots/file-filter/) workflows for this.
 
 > [!Note]
 > PNG optimization uses only lossless (optipng) compressors by default. To also enable lossy compression (pngquant), set \`lossy: true\`. When enabled, both lossy and lossless compressors compete and the smallest result wins, which may cause color shifts in some images.

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

@@ -42,6 +42,7 @@ export declare const oneTextSchema: z.ZodObject<{
     y_offset?: number | undefined;
 }>;
 export declare const robotImageResizeInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -328,6 +329,7 @@ export declare const robotImageResizeInstructionsSchema: z.ZodObject<{
     }[] | undefined;
     type?: "Bilevel" | "ColorSeparation" | "ColorSeparationAlpha" | "Grayscale" | "GrayscaleAlpha" | "Palette" | "PaletteAlpha" | "TrueColor" | "TrueColorAlpha" | undefined;
     alpha?: "Transparent" | "Remove" | "Set" | "Activate" | "Background" | "Copy" | "Deactivate" | "Extract" | "Off" | "On" | "Opaque" | "Shape" | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -391,6 +393,7 @@ export declare const robotImageResizeInstructionsSchema: z.ZodObject<{
     strip?: boolean | undefined;
     alpha?: "Transparent" | "Remove" | "Set" | "Activate" | "Background" | "Copy" | "Deactivate" | "Extract" | "Off" | "On" | "Opaque" | "Shape" | undefined;
     compress?: "None" | "BZip" | "Fax" | "Group4" | "JPEG" | "JPEG2000" | "Lossless" | "LZW" | "RLE" | "Zip" | null | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -464,6 +467,7 @@ export declare const robotImageResizeInstructionsSchema: z.ZodObject<{
     shave?: string | number | undefined;
 }>;
 export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -760,6 +764,7 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
     }[] | undefined;
     type?: "Bilevel" | "ColorSeparation" | "ColorSeparationAlpha" | "Grayscale" | "GrayscaleAlpha" | "Palette" | "PaletteAlpha" | "TrueColor" | "TrueColorAlpha" | undefined;
     alpha?: "Transparent" | "Remove" | "Set" | "Activate" | "Background" | "Copy" | "Deactivate" | "Extract" | "Off" | "On" | "Opaque" | "Shape" | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -788,8 +793,8 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
     transparent?: string | undefined;
     watermark_url?: string | undefined;
     watermark_size?: 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;
     stack?: 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;
     preclip_alpha?: "Transparent" | "Remove" | "Set" | "Activate" | "Background" | "Copy" | "Deactivate" | "Extract" | "Off" | "On" | "Opaque" | "Shape" | undefined;
     shave?: string | undefined;
     watermark_position_x?: number | undefined;
@@ -829,6 +834,7 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
     strip?: boolean | undefined;
     alpha?: "Transparent" | "Remove" | "Set" | "Activate" | "Background" | "Copy" | "Deactivate" | "Extract" | "Off" | "On" | "Opaque" | "Shape" | undefined;
     compress?: "None" | "BZip" | "Fax" | "Group4" | "JPEG" | "JPEG2000" | "Lossless" | "LZW" | "RLE" | "Zip" | null | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -869,10 +875,10 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
     watermark_resize_strategy?: "fit" | "min_fit" | "stretch" | "area" | undefined;
     watermark_opacity?: number | undefined;
     format?: string | null | undefined;
+    stack?: string | undefined;
     density?: string | null | 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;
     trim_whitespace?: boolean | undefined;
-    stack?: string | undefined;
     frame?: number | null | undefined;
     quality?: number | undefined;
     adaptive_filtering?: boolean | undefined;
@@ -907,6 +913,7 @@ export declare const robotImageResizeInstructionsWithHiddenFieldsSchema: z.ZodOb
 export type RobotImageResizeInstructions = z.infer<typeof robotImageResizeInstructionsSchema>;
 export type RobotImageResizeInstructionsWithHiddenFields = z.infer<typeof robotImageResizeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageResizeInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -1190,6 +1197,7 @@ export declare const interpolatableRobotImageResizeInstructionsSchema: z.ZodObje
     })[] | undefined;
     type?: string | undefined;
     alpha?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -1253,6 +1261,7 @@ export declare const interpolatableRobotImageResizeInstructionsSchema: z.ZodObje
     strip?: string | boolean | undefined;
     alpha?: string | undefined;
     compress?: string | null | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -1328,6 +1337,7 @@ export declare const interpolatableRobotImageResizeInstructionsSchema: z.ZodObje
 export type InterpolatableRobotImageResizeInstructions = InterpolatableRobotImageResizeInstructionsInput;
 export type InterpolatableRobotImageResizeInstructionsInput = z.input<typeof interpolatableRobotImageResizeInstructionsSchema>;
 export declare const interpolatableRobotImageResizeInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -1621,6 +1631,7 @@ export declare const interpolatableRobotImageResizeInstructionsWithHiddenFieldsS
     })[] | undefined;
     type?: string | undefined;
     alpha?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -1649,8 +1660,8 @@ export declare const interpolatableRobotImageResizeInstructionsWithHiddenFieldsS
     transparent?: string | undefined;
     watermark_url?: string | undefined;
     watermark_size?: string | undefined;
-    colorspace?: string | undefined;
     stack?: string | undefined;
+    colorspace?: string | undefined;
     preclip_alpha?: string | undefined;
     shave?: string | undefined;
     watermark_position_x?: string | number | undefined;
@@ -1690,6 +1701,7 @@ export declare const interpolatableRobotImageResizeInstructionsWithHiddenFieldsS
     strip?: string | boolean | undefined;
     alpha?: string | undefined;
     compress?: string | null | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -1730,10 +1742,10 @@ export declare const interpolatableRobotImageResizeInstructionsWithHiddenFieldsS
     watermark_resize_strategy?: string | undefined;
     watermark_opacity?: string | number | undefined;
     format?: string | null | undefined;
+    stack?: string | undefined;
     density?: string | null | undefined;
     colorspace?: string | undefined;
     trim_whitespace?: string | boolean | undefined;
-    stack?: string | undefined;
     frame?: string | number | null | undefined;
     quality?: string | number | undefined;
     adaptive_filtering?: string | boolean | undefined;

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

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

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

@@ -141,7 +141,7 @@ export const robotImageResizeInstructionsSchema = robotBase
         .describe(`
 The output format for the modified image.
 
-Some of the most important available formats are \`"jpg"\`, \`"png"\`, \`"gif"\`, and \`"tiff"\`. For a complete lists of all formats that we can write to please check [our supported image formats list](/docs/supported-formats/image-formats/).
+Some of the most important available formats are \`"jpg"\`, \`"png"\`, \`"gif"\`, \`"tiff"\`, and \`"jxl"\` for JPEG XL. For a complete list of all formats that we can write to, please check [our supported image formats list](/docs/supported-formats/image-formats/).
 
 If \`null\` (default), then the input image's format will be used as the output format.
 

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageUpscaleInstructionsSchema: 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">>]>>;
     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"]>>;
@@ -66,6 +67,7 @@ export declare const robotImageUpscaleInstructionsSchema: z.ZodObject<{
     result: boolean;
     force_accept: boolean;
     ignore_errors: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -87,6 +89,7 @@ export declare const robotImageUpscaleInstructionsSchema: z.ZodObject<{
     face_enhance?: boolean | undefined;
 }, {
     robot: "/image/upscale";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -111,6 +114,7 @@ export declare const robotImageUpscaleInstructionsSchema: z.ZodObject<{
     face_enhance?: boolean | undefined;
 }>;
 export declare const robotImageUpscaleInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -174,6 +178,7 @@ export declare const robotImageUpscaleInstructionsWithHiddenFieldsSchema: z.ZodO
     robot: "/image/upscale";
     force_accept: boolean;
     ignore_errors: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -197,6 +202,7 @@ export declare const robotImageUpscaleInstructionsWithHiddenFieldsSchema: z.ZodO
     face_enhance?: boolean | undefined;
 }, {
     robot: "/image/upscale";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -224,6 +230,7 @@ export declare const robotImageUpscaleInstructionsWithHiddenFieldsSchema: z.ZodO
 export type RobotImageUpscaleInstructions = z.infer<typeof robotImageUpscaleInstructionsSchema>;
 export type RobotImageUpscaleInstructionsWithHiddenFields = z.infer<typeof robotImageUpscaleInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageUpscaleInstructionsSchema: 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">>]>>;
     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"]>]>>;
@@ -286,6 +293,7 @@ export declare const interpolatableRobotImageUpscaleInstructionsSchema: z.ZodObj
     result: string | boolean;
     force_accept: string | boolean;
     ignore_errors: string | string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -307,6 +315,7 @@ export declare const interpolatableRobotImageUpscaleInstructionsSchema: z.ZodObj
     face_enhance?: string | boolean | undefined;
 }, {
     robot: "/image/upscale";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -333,6 +342,7 @@ export declare const interpolatableRobotImageUpscaleInstructionsSchema: z.ZodObj
 export type InterpolatableRobotImageUpscaleInstructions = InterpolatableRobotImageUpscaleInstructionsInput;
 export type InterpolatableRobotImageUpscaleInstructionsInput = z.input<typeof interpolatableRobotImageUpscaleInstructionsSchema>;
 export declare const interpolatableRobotImageUpscaleInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -395,6 +405,7 @@ export declare const interpolatableRobotImageUpscaleInstructionsWithHiddenFields
     robot: "/image/upscale";
     force_accept: string | boolean;
     ignore_errors: string | string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -418,6 +429,7 @@ export declare const interpolatableRobotImageUpscaleInstructionsWithHiddenFields
     face_enhance?: string | boolean | undefined;
 }, {
     robot: "/image/upscale";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"image-upscale.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-upscale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"image-upscale.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-upscale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAmClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5D,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/mega-import.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotMegaImportInstructionsSchema: 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">>]>>;
     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>;
@@ -33,6 +34,7 @@ export declare const robotMegaImportInstructionsSchema: z.ZodObject<{
     return_file_stubs: boolean;
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
     queue?: "batch" | undefined;
@@ -45,6 +47,7 @@ export declare const robotMegaImportInstructionsSchema: z.ZodObject<{
     robot: "/mega/import";
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
     queue?: "batch" | undefined;
@@ -61,6 +64,7 @@ export declare const robotMegaImportInstructionsSchema: z.ZodObject<{
     return_file_stubs?: boolean | undefined;
 }>;
 export declare const robotMegaImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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>;
@@ -92,6 +96,7 @@ export declare const robotMegaImportInstructionsWithHiddenFieldsSchema: z.ZodObj
     return_file_stubs: boolean;
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
@@ -104,6 +109,7 @@ export declare const robotMegaImportInstructionsWithHiddenFieldsSchema: z.ZodObj
     robot: "/mega/import";
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
@@ -122,6 +128,7 @@ export declare const robotMegaImportInstructionsWithHiddenFieldsSchema: z.ZodObj
 export type RobotMegaImportInstructions = z.infer<typeof robotMegaImportInstructionsSchema>;
 export type RobotMegaImportInstructionsWithHiddenFields = z.infer<typeof robotMegaImportInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotMegaImportInstructionsSchema: 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">>]>>;
     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]>>;
@@ -152,6 +159,7 @@ export declare const interpolatableRobotMegaImportInstructionsSchema: z.ZodObjec
     return_file_stubs: string | boolean;
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
@@ -164,6 +172,7 @@ export declare const interpolatableRobotMegaImportInstructionsSchema: z.ZodObjec
     robot: "/mega/import";
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
@@ -182,6 +191,7 @@ export declare const interpolatableRobotMegaImportInstructionsSchema: z.ZodObjec
 export type InterpolatableRobotMegaImportInstructions = InterpolatableRobotMegaImportInstructionsInput;
 export type InterpolatableRobotMegaImportInstructionsInput = z.input<typeof interpolatableRobotMegaImportInstructionsSchema>;
 export declare const interpolatableRobotMegaImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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]>>;
@@ -212,6 +222,7 @@ export declare const interpolatableRobotMegaImportInstructionsWithHiddenFieldsSc
     return_file_stubs: string | boolean;
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
@@ -224,6 +235,7 @@ export declare const interpolatableRobotMegaImportInstructionsWithHiddenFieldsSc
     robot: "/mega/import";
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;

package/dist/alphalib/types/robots/mega-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mega-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/mega-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAanE,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"mega-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/mega-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAanE,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}