npm - @transloadit/node - Versions diffs - 4.10.2 → 4.10.4 - Mend

@transloadit/node 4.10.2 → 4.10.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (251) hide show

package/dist/alphalib/types/robots/cloudflare-store.d.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotCloudflareStoreInstructionsSchema: 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"]>>;
@@ -77,6 +78,7 @@ export declare const robotCloudflareStoreInstructionsSchema: z.ZodObject<{
     ignore_errors: string[];
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -104,6 +106,7 @@ export declare const robotCloudflareStoreInstructionsSchema: z.ZodObject<{
     host?: string | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -130,6 +133,7 @@ export declare const robotCloudflareStoreInstructionsSchema: z.ZodObject<{
     url_prefix?: string | undefined;
 }>;
 export declare const robotCloudflareStoreInstructionsWithHiddenFieldsSchema: 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>;
@@ -202,6 +206,7 @@ export declare const robotCloudflareStoreInstructionsWithHiddenFieldsSchema: z.Z
     ignore_errors: string[];
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -230,6 +235,7 @@ export declare const robotCloudflareStoreInstructionsWithHiddenFieldsSchema: z.Z
     host?: string | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -258,6 +264,7 @@ export declare const robotCloudflareStoreInstructionsWithHiddenFieldsSchema: z.Z
 export type RobotCloudflareStoreInstructions = z.infer<typeof robotCloudflareStoreInstructionsSchema>;
 export type RobotCloudflareStoreInstructionsWithHiddenFields = z.infer<typeof robotCloudflareStoreInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotCloudflareStoreInstructionsSchema: 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"]>]>>;
@@ -330,6 +337,7 @@ export declare const interpolatableRobotCloudflareStoreInstructionsSchema: z.Zod
     ignore_errors: string | string[];
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -357,6 +365,7 @@ export declare const interpolatableRobotCloudflareStoreInstructionsSchema: z.Zod
     host?: string | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -385,6 +394,7 @@ export declare const interpolatableRobotCloudflareStoreInstructionsSchema: z.Zod
 export type InterpolatableRobotCloudflareStoreInstructions = InterpolatableRobotCloudflareStoreInstructionsInput;
 export type InterpolatableRobotCloudflareStoreInstructionsInput = z.input<typeof interpolatableRobotCloudflareStoreInstructionsSchema>;
 export declare const interpolatableRobotCloudflareStoreInstructionsWithHiddenFieldsSchema: 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]>>;
@@ -456,6 +466,7 @@ export declare const interpolatableRobotCloudflareStoreInstructionsWithHiddenFie
     ignore_errors: string | string[];
     host?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -484,6 +495,7 @@ export declare const interpolatableRobotCloudflareStoreInstructionsWithHiddenFie
     host?: string | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

package/dist/alphalib/types/robots/cloudflare-store.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"cloudflare-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudflare-store.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,cAuClB,CAAA;AAED,eAAO,MAAM,sCAAsC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAkCxC,CAAA;AAEX,eAAO,MAAM,sDAAsD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}
1	+ {"version":3,"file":"cloudflare-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudflare-store.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,cAuClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}

package/dist/alphalib/types/robots/digitalocean-import.d.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotDigitaloceanImportInstructionsSchema: 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"]>>;
@@ -34,6 +35,7 @@ export declare const robotDigitaloceanImportInstructionsSchema: z.ZodObject<{
     page_number: number;
     return_file_stubs: boolean;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
@@ -44,6 +46,7 @@ export declare const robotDigitaloceanImportInstructionsSchema: z.ZodObject<{
     path: string | string[];
     robot: "/digitalocean/import";
     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;
@@ -60,6 +63,7 @@ export declare const robotDigitaloceanImportInstructionsSchema: z.ZodObject<{
     return_file_stubs?: boolean | undefined;
 }>;
 export declare const robotDigitaloceanImportInstructionsWithHiddenFieldsSchema: 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>;
@@ -89,6 +93,7 @@ export declare const robotDigitaloceanImportInstructionsWithHiddenFieldsSchema:
     page_number: number;
     return_file_stubs: boolean;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
@@ -100,6 +105,7 @@ export declare const robotDigitaloceanImportInstructionsWithHiddenFieldsSchema:
     path: string | string[];
     robot: "/digitalocean/import";
     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;
@@ -118,6 +124,7 @@ export declare const robotDigitaloceanImportInstructionsWithHiddenFieldsSchema:
 export type RobotDigitaloceanImportInstructions = z.infer<typeof robotDigitaloceanImportInstructionsSchema>;
 export type RobotDigitaloceanImportInstructionsWithHiddenFields = z.infer<typeof robotDigitaloceanImportInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDigitaloceanImportInstructionsSchema: 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"]>]>>;
@@ -147,6 +154,7 @@ export declare const interpolatableRobotDigitaloceanImportInstructionsSchema: z.
     page_number: string | number;
     return_file_stubs: string | boolean;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
@@ -157,6 +165,7 @@ export declare const interpolatableRobotDigitaloceanImportInstructionsSchema: z.
     path: string | string[];
     robot: "/digitalocean/import";
     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;
@@ -175,6 +184,7 @@ export declare const interpolatableRobotDigitaloceanImportInstructionsSchema: z.
 export type InterpolatableRobotDigitaloceanImportInstructions = InterpolatableRobotDigitaloceanImportInstructionsInput;
 export type InterpolatableRobotDigitaloceanImportInstructionsInput = z.input<typeof interpolatableRobotDigitaloceanImportInstructionsSchema>;
 export declare const interpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsSchema: 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]>>;
@@ -203,6 +213,7 @@ export declare const interpolatableRobotDigitaloceanImportInstructionsWithHidden
     page_number: string | number;
     return_file_stubs: string | boolean;
     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;
@@ -214,6 +225,7 @@ export declare const interpolatableRobotDigitaloceanImportInstructionsWithHidden
     path: string | string[];
     robot: "/digitalocean/import";
     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/digitalocean-import.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"digitalocean-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-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,cAqClB,CAAA;AAED,eAAO,MAAM,yCAAyC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EA6B3C,CAAA;AAEX,eAAO,MAAM,yDAAyD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAKlE,CAAA;AAEJ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,yDAAyD,CACjE,CAAA;AAED,eAAO,MAAM,uDAAuD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAEnE,CAAA;AACD,MAAM,MAAM,iDAAiD,GAC3D,sDAAsD,CAAA;AAExD,MAAM,MAAM,sDAAsD,GAAG,CAAC,CAAC,KAAK,CAC1E,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,uEAAuE~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EACP,CAAA;AAC7E,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,uEAAuE,CAC/E,CAAA;AACD,MAAM,MAAM,sEAAsE,GAAG,CAAC,CAAC,KAAK,CAC1F,OAAO,uEAAuE,CAC/E,CAAA"}
1	+ {"version":3,"file":"digitalocean-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-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,cAqClB,CAAA;AAED,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B3C,CAAA;AAEX,eAAO,MAAM,yDAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKlE,CAAA;AAEJ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,yDAAyD,CACjE,CAAA;AAED,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnE,CAAA;AACD,MAAM,MAAM,iDAAiD,GAC3D,sDAAsD,CAAA;AAExD,MAAM,MAAM,sDAAsD,GAAG,CAAC,CAAC,KAAK,CAC1E,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC7E,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,uEAAuE,CAC/E,CAAA;AACD,MAAM,MAAM,sEAAsE,GAAG,CAAC,CAAC,KAAK,CAC1F,OAAO,uEAAuE,CAC/E,CAAA"}

package/dist/alphalib/types/robots/digitalocean-store.d.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotDigitaloceanStoreInstructionsSchema: 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"]>>;
@@ -79,6 +80,7 @@ export declare const robotDigitaloceanStoreInstructionsSchema: z.ZodObject<{
     url_prefix: string;
     acl: "private" | "public-read";
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -105,6 +107,7 @@ export declare const robotDigitaloceanStoreInstructionsSchema: z.ZodObject<{
     headers?: Record<string, string> | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -133,6 +136,7 @@ export declare const robotDigitaloceanStoreInstructionsSchema: z.ZodObject<{
     acl?: "private" | "public-read" | undefined;
 }>;
 export declare const robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: 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>;
@@ -207,6 +211,7 @@ export declare const robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: z
     url_prefix: string;
     acl: "private" | "public-read";
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -234,6 +239,7 @@ export declare const robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: z
     headers?: Record<string, string> | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -264,6 +270,7 @@ export declare const robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: z
 export type RobotDigitaloceanStoreInstructions = z.infer<typeof robotDigitaloceanStoreInstructionsSchema>;
 export type RobotDigitaloceanStoreInstructionsWithHiddenFields = z.infer<typeof robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDigitaloceanStoreInstructionsSchema: 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"]>]>>;
@@ -338,6 +345,7 @@ export declare const interpolatableRobotDigitaloceanStoreInstructionsSchema: z.Z
     url_prefix: string;
     acl: string;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -364,6 +372,7 @@ export declare const interpolatableRobotDigitaloceanStoreInstructionsSchema: z.Z
     headers?: Record<string, string> | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -394,6 +403,7 @@ export declare const interpolatableRobotDigitaloceanStoreInstructionsSchema: z.Z
 export type InterpolatableRobotDigitaloceanStoreInstructions = InterpolatableRobotDigitaloceanStoreInstructionsInput;
 export type InterpolatableRobotDigitaloceanStoreInstructionsInput = z.input<typeof interpolatableRobotDigitaloceanStoreInstructionsSchema>;
 export declare const interpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: 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]>>;
@@ -467,6 +477,7 @@ export declare const interpolatableRobotDigitaloceanStoreInstructionsWithHiddenF
     url_prefix: string;
     acl: string;
     key?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -494,6 +505,7 @@ export declare const interpolatableRobotDigitaloceanStoreInstructionsWithHiddenF
     headers?: Record<string, string> | undefined;
     path?: string | undefined;
     key?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

package/dist/alphalib/types/robots/digitalocean-store.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"digitalocean-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-store.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,cAoClB,CAAA;AAED,eAAO,MAAM,wCAAwC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EA0C1C,CAAA;AAEX,eAAO,MAAM,wDAAwD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAKjE,CAAA;AAEJ,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,wDAAwD,CAChE,CAAA;AAED,eAAO,MAAM,sDAAsD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAElE,CAAA;AACD,MAAM,MAAM,gDAAgD,GAC1D,qDAAqD,CAAA;AAEvD,MAAM,MAAM,qDAAqD,GAAG,CAAC,CAAC,KAAK,CACzE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,sEAAsE~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EACP,CAAA;AAC5E,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,sEAAsE,CAC9E,CAAA;AACD,MAAM,MAAM,qEAAqE,GAAG,CAAC,CAAC,KAAK,CACzF,OAAO,sEAAsE,CAC9E,CAAA"}
1	+ {"version":3,"file":"digitalocean-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-store.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,cAoClB,CAAA;AAED,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C1C,CAAA;AAEX,eAAO,MAAM,wDAAwD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjE,CAAA;AAEJ,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,wDAAwD,CAChE,CAAA;AAED,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElE,CAAA;AACD,MAAM,MAAM,gDAAgD,GAC1D,qDAAqD,CAAA;AAEvD,MAAM,MAAM,qDAAqD,GAAG,CAAC,CAAC,KAAK,CACzE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,sEAAsE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC5E,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,sEAAsE,CAC9E,CAAA;AACD,MAAM,MAAM,qEAAqE,GAAG,CAAC,CAAC,KAAK,CACzF,OAAO,sEAAsE,CAC9E,CAAA"}

package/dist/alphalib/types/robots/document-autorotate.d.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotDocumentAutorotateInstructionsSchema: 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"]>>;
@@ -63,6 +64,7 @@ export declare const robotDocumentAutorotateInstructionsSchema: z.ZodObject<{
     result: boolean;
     force_accept: boolean;
     ignore_errors: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -81,6 +83,7 @@ export declare const robotDocumentAutorotateInstructionsSchema: z.ZodObject<{
     queue?: "batch" | undefined;
 }, {
     robot: "/document/autorotate";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -102,6 +105,7 @@ export declare const robotDocumentAutorotateInstructionsSchema: z.ZodObject<{
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
 }>;
 export declare const robotDocumentAutorotateInstructionsWithHiddenFieldsSchema: 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>;
@@ -161,6 +165,7 @@ export declare const robotDocumentAutorotateInstructionsWithHiddenFieldsSchema:
     robot: "/document/autorotate";
     force_accept: boolean;
     ignore_errors: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -180,6 +185,7 @@ export declare const robotDocumentAutorotateInstructionsWithHiddenFieldsSchema:
     queue?: "batch" | undefined;
 }, {
     robot: "/document/autorotate";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -203,6 +209,7 @@ export declare const robotDocumentAutorotateInstructionsWithHiddenFieldsSchema:
 export type RobotDocumentAutorotateInstructions = z.infer<typeof robotDocumentAutorotateInstructionsSchema>;
 export type RobotDocumentAutorotateInstructionsWithHiddenFields = z.infer<typeof robotDocumentAutorotateInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentAutorotateInstructionsSchema: 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"]>]>>;
@@ -262,6 +269,7 @@ export declare const interpolatableRobotDocumentAutorotateInstructionsSchema: z.
     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;
@@ -280,6 +288,7 @@ export declare const interpolatableRobotDocumentAutorotateInstructionsSchema: z.
     queue?: string | undefined;
 }, {
     robot: "/document/autorotate";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -303,6 +312,7 @@ export declare const interpolatableRobotDocumentAutorotateInstructionsSchema: z.
 export type InterpolatableRobotDocumentAutorotateInstructions = InterpolatableRobotDocumentAutorotateInstructionsInput;
 export type InterpolatableRobotDocumentAutorotateInstructionsInput = z.input<typeof interpolatableRobotDocumentAutorotateInstructionsSchema>;
 export declare const interpolatableRobotDocumentAutorotateInstructionsWithHiddenFieldsSchema: 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]>>;
@@ -361,6 +371,7 @@ export declare const interpolatableRobotDocumentAutorotateInstructionsWithHidden
     robot: "/document/autorotate";
     force_accept: string | boolean;
     ignore_errors: string | string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -380,6 +391,7 @@ export declare const interpolatableRobotDocumentAutorotateInstructionsWithHidden
     queue?: string | undefined;
 }, {
     robot: "/document/autorotate";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

package/dist/alphalib/types/robots/document-autorotate.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"document-autorotate.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/document-autorotate.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,yCAAyC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAK3C,CAAA;AAEX,eAAO,MAAM,yDAAyD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAKlE,CAAA;AAEJ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,yDAAyD,CACjE,CAAA;AAED,eAAO,MAAM,uDAAuD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAEnE,CAAA;AACD,MAAM,MAAM,iDAAiD,GAC3D,sDAAsD,CAAA;AAExD,MAAM,MAAM,sDAAsD,GAAG,CAAC,CAAC,KAAK,CAC1E,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,uEAAuE~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EACP,CAAA;AAC7E,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,uEAAuE,CAC/E,CAAA;AACD,MAAM,MAAM,sEAAsE,GAAG,CAAC,CAAC,KAAK,CAC1F,OAAO,uEAAuE,CAC/E,CAAA"}
1	+ {"version":3,"file":"document-autorotate.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/document-autorotate.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,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK3C,CAAA;AAEX,eAAO,MAAM,yDAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKlE,CAAA;AAEJ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,yDAAyD,CACjE,CAAA;AAED,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnE,CAAA;AACD,MAAM,MAAM,iDAAiD,GAC3D,sDAAsD,CAAA;AAExD,MAAM,MAAM,sDAAsD,GAAG,CAAC,CAAC,KAAK,CAC1E,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC7E,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,uEAAuE,CAC/E,CAAA;AACD,MAAM,MAAM,sEAAsE,GAAG,CAAC,CAAC,KAAK,CAC1F,OAAO,uEAAuE,CAC/E,CAAA"}

package/dist/alphalib/types/robots/document-convert.d.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotDocumentConvertInstructionsSchema: 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"]>>;
@@ -79,6 +80,7 @@ export declare const robotDocumentConvertInstructionsSchema: z.ZodObject<{
     pdf_print_background: boolean;
     pdf_format: "A0" | "A1" | "A2" | "A3" | "A4" | "A5" | "A6" | "Ledger" | "Legal" | "Letter" | "Tabloid";
     pdf_display_header_footer: boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -100,6 +102,7 @@ export declare const robotDocumentConvertInstructionsSchema: z.ZodObject<{
 }, {
     robot: "/document/convert";
     format: "text" | "doc" | "gif" | "pdf" | "ai" | "csv" | "docx" | "eps" | "html" | "jpeg" | "jpg" | "latex" | "md" | "oda" | "odd" | "odt" | "ott" | "png" | "pot" | "pps" | "ppt" | "pptx" | "ppz" | "ps" | "rtf" | "rtx" | "srt" | "svg" | "txt" | "vtt" | "xhtml" | "xla" | "xls" | "xlsx" | "xml";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -129,6 +132,7 @@ export declare const robotDocumentConvertInstructionsSchema: z.ZodObject<{
     pdf_footer_template?: string | undefined;
 }>;
 export declare const robotDocumentConvertInstructionsWithHiddenFieldsSchema: 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>;
@@ -204,6 +208,7 @@ export declare const robotDocumentConvertInstructionsWithHiddenFieldsSchema: z.Z
     pdf_print_background: boolean;
     pdf_format: "A0" | "A1" | "A2" | "A3" | "A4" | "A5" | "A6" | "Ledger" | "Legal" | "Letter" | "Tabloid";
     pdf_display_header_footer: boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -226,6 +231,7 @@ export declare const robotDocumentConvertInstructionsWithHiddenFieldsSchema: z.Z
 }, {
     robot: "/document/convert";
     format: "text" | "doc" | "gif" | "pdf" | "ai" | "csv" | "docx" | "eps" | "html" | "jpeg" | "jpg" | "latex" | "md" | "oda" | "odd" | "odt" | "ott" | "png" | "pot" | "pps" | "ppt" | "pptx" | "ppz" | "ps" | "rtf" | "rtx" | "srt" | "svg" | "txt" | "vtt" | "xhtml" | "xla" | "xls" | "xlsx" | "xml";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -257,6 +263,7 @@ export declare const robotDocumentConvertInstructionsWithHiddenFieldsSchema: z.Z
 export type RobotDocumentConvertInstructions = z.infer<typeof robotDocumentConvertInstructionsSchema>;
 export type RobotDocumentConvertInstructionsWithHiddenFields = z.infer<typeof robotDocumentConvertInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentConvertInstructionsSchema: 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"]>]>>;
@@ -332,6 +339,7 @@ export declare const interpolatableRobotDocumentConvertInstructionsSchema: z.Zod
     pdf_print_background: string | boolean;
     pdf_format: string;
     pdf_display_header_footer: string | boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -353,6 +361,7 @@ export declare const interpolatableRobotDocumentConvertInstructionsSchema: z.Zod
 }, {
     robot: "/document/convert";
     format: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -384,6 +393,7 @@ export declare const interpolatableRobotDocumentConvertInstructionsSchema: z.Zod
 export type InterpolatableRobotDocumentConvertInstructions = InterpolatableRobotDocumentConvertInstructionsInput;
 export type InterpolatableRobotDocumentConvertInstructionsInput = z.input<typeof interpolatableRobotDocumentConvertInstructionsSchema>;
 export declare const interpolatableRobotDocumentConvertInstructionsWithHiddenFieldsSchema: 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]>>;
@@ -458,6 +468,7 @@ export declare const interpolatableRobotDocumentConvertInstructionsWithHiddenFie
     pdf_print_background: string | boolean;
     pdf_format: string;
     pdf_display_header_footer: string | boolean;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -480,6 +491,7 @@ export declare const interpolatableRobotDocumentConvertInstructionsWithHiddenFie
 }, {
     robot: "/document/convert";
     format: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

package/dist/alphalib/types/robots/document-convert.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"document-convert.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/document-convert.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,cA6FlB,CAAA;AAED,eAAO,MAAM,sCAAsC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EA+KxC,CAAA;AAEX,eAAO,MAAM,sDAAsD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~EACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}
1	+ {"version":3,"file":"document-convert.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/document-convert.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,cA6FlB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+KxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}

package/dist/alphalib/types/robots/document-merge.d.ts CHANGED Viewed

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotDocumentMergeInstructionsSchema: 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 robotDocumentMergeInstructionsSchema: z.ZodObject<{
     force_accept: boolean;
     ignore_errors: string[];
     input_passwords: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -85,6 +87,7 @@ export declare const robotDocumentMergeInstructionsSchema: z.ZodObject<{
     output_password?: string | undefined;
 }, {
     robot: "/document/merge";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -108,6 +111,7 @@ export declare const robotDocumentMergeInstructionsSchema: z.ZodObject<{
     output_password?: string | undefined;
 }>;
 export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: 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>;
@@ -170,6 +174,7 @@ export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: z.Zod
     force_accept: boolean;
     ignore_errors: string[];
     input_passwords: string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -190,6 +195,7 @@ export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: z.Zod
     output_password?: string | undefined;
 }, {
     robot: "/document/merge";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -215,6 +221,7 @@ export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: z.Zod
 export type RobotDocumentMergeInstructions = z.infer<typeof robotDocumentMergeInstructionsSchema>;
 export type RobotDocumentMergeInstructionsWithHiddenFields = z.infer<typeof robotDocumentMergeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentMergeInstructionsSchema: 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"]>]>>;
@@ -277,6 +284,7 @@ export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodOb
     force_accept: string | boolean;
     ignore_errors: string | string[];
     input_passwords: string | string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -296,6 +304,7 @@ export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodOb
     output_password?: string | undefined;
 }, {
     robot: "/document/merge";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -321,6 +330,7 @@ export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodOb
 export type InterpolatableRobotDocumentMergeInstructions = InterpolatableRobotDocumentMergeInstructionsInput;
 export type InterpolatableRobotDocumentMergeInstructionsInput = z.input<typeof interpolatableRobotDocumentMergeInstructionsSchema>;
 export declare const interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema: 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]>>;
@@ -382,6 +392,7 @@ export declare const interpolatableRobotDocumentMergeInstructionsWithHiddenField
     force_accept: string | boolean;
     ignore_errors: string | string[];
     input_passwords: string | string[];
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -402,6 +413,7 @@ export declare const interpolatableRobotDocumentMergeInstructionsWithHiddenField
     output_password?: string | undefined;
 }, {
     robot: "/document/merge";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;