@transloadit/zod 4.4.1 → 5.0.0

package/dist/v3/robots/azure-store.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotAzureStoreInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -72,16 +73,16 @@ export declare const robotAzureStoreInstructionsSchema: z.ZodObject<{
     cache_control: z.ZodOptional<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, string, string | number | boolean>>>;
     sas_expires_in: z.ZodOptional<z.ZodNumber>;
-    sas_permissions: z.ZodOptional<z.ZodString>;
+    sas_permissions: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/azure/store";
     result: boolean;
+    robot: "/azure/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     metadata: Record<string, string>;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -96,6 +97,7 @@ export declare const robotAzureStoreInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
@@ -112,7 +114,7 @@ export declare const robotAzureStoreInstructionsSchema: z.ZodObject<{
     robot: "/azure/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -127,8 +129,9 @@ export declare const robotAzureStoreInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
@@ -144,9 +147,14 @@ export declare const robotAzureStoreInstructionsSchema: z.ZodObject<{
     sas_expires_in?: number | undefined;
     sas_permissions?: string | undefined;
 }>;
+declare const hiddenFields: {
+    upload_stack: z.ZodOptional<z.ZodEnum<["v1", "v2"]>>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotAzureStoreInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
@@ -211,18 +219,19 @@ export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObj
     cache_control: z.ZodOptional<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, string, string | number | boolean>>>;
     sas_expires_in: z.ZodOptional<z.ZodNumber>;
-    sas_permissions: z.ZodOptional<z.ZodString>;
+    sas_permissions: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 } & {
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
     upload_stack: z.ZodOptional<z.ZodEnum<["v1", "v2"]>>;
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/azure/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     metadata: Record<string, string>;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -237,8 +246,8 @@ export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObj
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
     account?: string | undefined;
@@ -255,7 +264,7 @@ export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObj
     robot: "/azure/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -270,8 +279,9 @@ export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObj
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
@@ -287,12 +297,10 @@ export declare const robotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObj
     sas_expires_in?: number | undefined;
     sas_permissions?: string | undefined;
     upload_stack?: "v2" | "v1" | undefined;
-}>;
-export type RobotAzureStoreInstructions = z.infer<typeof robotAzureStoreInstructionsSchema>;
-export type RobotAzureStoreInstructionsWithHiddenFields = z.infer<typeof robotAzureStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotAzureStoreInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotAzureStoreInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -358,16 +366,16 @@ export declare const interpolatableRobotAzureStoreInstructionsSchema: z.ZodObjec
     cache_control: z.ZodOptional<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, string, string | number | boolean>]>>>;
     sas_expires_in: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    sas_permissions: z.ZodOptional<z.ZodString>;
+    sas_permissions: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodString, string, string>]>>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/azure/store";
     result: string | boolean;
+    robot: "/azure/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     metadata: Record<string, string>;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -382,6 +390,7 @@ export declare const interpolatableRobotAzureStoreInstructionsSchema: z.ZodObjec
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
@@ -398,7 +407,7 @@ export declare const interpolatableRobotAzureStoreInstructionsSchema: z.ZodObjec
     robot: "/azure/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -413,8 +422,9 @@ export declare const interpolatableRobotAzureStoreInstructionsSchema: z.ZodObjec
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
@@ -429,12 +439,10 @@ export declare const interpolatableRobotAzureStoreInstructionsSchema: z.ZodObjec
     metadata?: Record<string, string | number | boolean> | undefined;
     sas_expires_in?: string | number | undefined;
     sas_permissions?: string | undefined;
-}>;
-export type InterpolatableRobotAzureStoreInstructions = InterpolatableRobotAzureStoreInstructionsInput;
-export type InterpolatableRobotAzureStoreInstructionsInput = z.input<typeof interpolatableRobotAzureStoreInstructionsSchema>;
-export declare const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
@@ -499,17 +507,18 @@ export declare const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSc
     cache_control: z.ZodOptional<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, string, string | number | boolean>]>>>;
     sas_expires_in: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    sas_permissions: z.ZodOptional<z.ZodString>;
+    sas_permissions: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodString, string, string>]>>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
     upload_stack: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["v1", "v2"]>]>>;
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/azure/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     metadata: Record<string, string>;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -524,8 +533,8 @@ export declare const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSc
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
     account?: string | undefined;
@@ -542,7 +551,7 @@ export declare const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSc
     robot: "/azure/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -557,8 +566,9 @@ export declare const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSc
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
@@ -575,6 +585,12 @@ export declare const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSc
     sas_permissions?: string | undefined;
     upload_stack?: string | undefined;
 }>;
-export type InterpolatableRobotAzureStoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotAzureStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotAzureStoreInstructions = Instructions['output'];
+export type RobotAzureStoreInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotAzureStoreInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotAzureStoreInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotAzureStoreInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotAzureStoreInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=azure-store.d.ts.map

package/dist/v3/robots/azure-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"azure-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/azure-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAMD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM1D,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":"azure-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/azure-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAiB1B,eAAO,MAAM,IAAI,EAAE,cAUlB,CAAA;AAOD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDnC,CAAA;AAEX,QAAA,MAAM,YAAY;;CAEjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,iCAAiC,CAAC,KAAK,EAC9C,OAAO,YAAY,CACiE,CAAA;AAEtF,eAAO,MACa,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACnD,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC/B,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC9E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,2BAA2B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAChE,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACtF,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC3F,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAChG,MAAM,MAAM,yDAAyD,GACnE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,8DAA8D,GACxE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v3/robots/azure-store.js

@@ -1,56 +1,24 @@
 import { z } from 'zod/v3';
-import { azureBase, interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { zodCodePointLength, zodInputPreservingTransform, zodWithJsonInputSchema, } from "../lib/zodInputSemantics.js";
+import { azureBase, createStorageStoreExample, defineRobotWithHiddenFields, robotBase, robotStoreMeta, robotUse, storePath, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 6,
-    discount_factor: 0.15000150001500018,
-    discount_pct: 84.99984999849998,
-    example_code: {
-        steps: {
-            exported: {
-                robot: '/azure/store',
-                use: ':original',
-                credentials: 'YOUR_AZURE_CREDENTIALS',
-                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
-            },
-        },
-    },
+    ...robotStoreMeta,
+    example_code: createStorageStoreExample('/azure/store', 'YOUR_AZURE_CREDENTIALS'),
     example_code_description: 'Export uploaded files to `my_target_folder` on Azure:',
     has_small_icon: true,
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Exporting',
     purpose_sentence: 'exports encoding results to Microsoft Azure',
-    purpose_verb: 'export',
     purpose_word: 'Azure',
     purpose_words: 'Export files to Microsoft Azure',
-    service_slug: 'file-exporting',
-    slot_count: 10,
     title: 'Export files to Microsoft Azure',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'AzureStoreRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
-const azureStoreMetadataValueSchema = z
-    .union([z.string(), z.number(), z.boolean()])
-    .transform(String);
+const azureStoreMetadataValueSchema = zodWithJsonInputSchema(zodInputPreservingTransform(z.union([z.string(), z.number(), z.boolean()]), String), z.union([z.string(), z.number().finite(), z.boolean()]));
 export const robotAzureStoreInstructionsSchema = robotBase
     .merge(robotUse)
     .merge(azureBase)
     .extend({
     robot: z.literal('/azure/store'),
-    path: z
-        .string()
-        .default('${unique_prefix}/${file.url_name}')
-        .describe(`
-The path at which the file is to be stored. This may include any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables).
-`),
+    path: storePath,
     content_type: z
         .string()
         .optional()
@@ -95,22 +63,15 @@ A JavaScript object containing a list of metadata to be set for this file on Azu
         .describe(`
 Set this to a number to enable shared access signatures for your stored object. This reflects the number of seconds that the signature will be valid for once the object is stored. Enabling this will attach the shared access signature (SAS) to the result URL of your object.
 `),
-    sas_permissions: z
-        .string()
-        .regex(/^[rdw]+$/)
-        .min(0)
-        .max(3)
+    sas_permissions: zodCodePointLength(z.string().regex(/^[rdw]+$/u), { max: 3 })
         .optional()
         .describe(`
 Set this to a combination of \`r\` (read), \`w\` (write) and \`d\` (delete) for your shared access signatures (SAS) permissions.
 `),
 })
     .strict();
-export const robotAzureStoreInstructionsWithHiddenFieldsSchema = robotAzureStoreInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotAzureStoreInstructionsSchema.shape.result])
-        .optional(),
+const hiddenFields = {
     upload_stack: z.enum(['v1', 'v2']).optional(),
-});
-export const interpolatableRobotAzureStoreInstructionsSchema = interpolateRobot(robotAzureStoreInstructionsSchema);
-export const interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotAzureStoreInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotAzureStoreInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotAzureStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotAzureStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotAzureStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v3/robots/backblaze-import.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotBackblazeImportInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -24,13 +25,14 @@ export declare const robotBackblazeImportInstructionsSchema: z.ZodObject<{
     files_per_page: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/backblaze/import";
     result: boolean;
+    robot: "/backblaze/import";
+    recursive: boolean;
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     files_per_page: number;
     start_file_name: string;
     interpolate?: boolean | Record<string, boolean> | undefined;
@@ -43,9 +45,11 @@ export declare const robotBackblazeImportInstructionsSchema: z.ZodObject<{
 }, {
     path: string | string[];
     robot: "/backblaze/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
+    recursive?: boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -55,13 +59,14 @@ export declare const robotBackblazeImportInstructionsSchema: z.ZodObject<{
     bucket?: string | undefined;
     app_key_id?: string | undefined;
     app_key?: string | undefined;
-    recursive?: boolean | undefined;
     files_per_page?: number | undefined;
     start_file_name?: string | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotBackblazeImportInstructionsSchema.shape>;
 export declare const robotBackblazeImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
@@ -81,16 +86,17 @@ export declare const robotBackblazeImportInstructionsWithHiddenFieldsSchema: z.Z
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/backblaze/import";
+    recursive: boolean;
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     files_per_page: number;
     start_file_name: string;
+    result?: boolean | "debug" | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
     bucket?: string | undefined;
@@ -99,9 +105,11 @@ export declare const robotBackblazeImportInstructionsWithHiddenFieldsSchema: z.Z
 }, {
     path: string | string[];
     robot: "/backblaze/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
+    recursive?: boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -111,15 +119,12 @@ export declare const robotBackblazeImportInstructionsWithHiddenFieldsSchema: z.Z
     bucket?: string | undefined;
     app_key_id?: string | undefined;
     app_key?: string | undefined;
-    recursive?: boolean | undefined;
     files_per_page?: number | undefined;
     start_file_name?: string | undefined;
-}>;
-export type RobotBackblazeImportInstructions = z.infer<typeof robotBackblazeImportInstructionsSchema>;
-export type RobotBackblazeImportInstructionsWithHiddenFields = z.infer<typeof robotBackblazeImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotBackblazeImportInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotBackblazeImportInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -137,13 +142,14 @@ export declare const interpolatableRobotBackblazeImportInstructionsSchema: z.Zod
     files_per_page: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/backblaze/import";
     result: string | boolean;
+    robot: "/backblaze/import";
+    recursive: string | boolean;
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     files_per_page: string | number;
     start_file_name: string;
     interpolate?: boolean | Record<string, boolean> | undefined;
@@ -156,9 +162,11 @@ export declare const interpolatableRobotBackblazeImportInstructionsSchema: z.Zod
 }, {
     path: string | string[];
     robot: "/backblaze/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    recursive?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -168,15 +176,12 @@ export declare const interpolatableRobotBackblazeImportInstructionsSchema: z.Zod
     bucket?: string | undefined;
     app_key_id?: string | undefined;
     app_key?: string | undefined;
-    recursive?: string | boolean | undefined;
     files_per_page?: string | number | undefined;
     start_file_name?: string | undefined;
-}>;
-export type InterpolatableRobotBackblazeImportInstructions = InterpolatableRobotBackblazeImportInstructionsInput;
-export type InterpolatableRobotBackblazeImportInstructionsInput = z.input<typeof interpolatableRobotBackblazeImportInstructionsSchema>;
-export declare const interpolatableRobotBackblazeImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotBackblazeImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
@@ -195,16 +200,17 @@ export declare const interpolatableRobotBackblazeImportInstructionsWithHiddenFie
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/backblaze/import";
+    recursive: string | boolean;
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     files_per_page: string | number;
     start_file_name: string;
+    result?: string | boolean | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
     bucket?: string | undefined;
@@ -213,9 +219,11 @@ export declare const interpolatableRobotBackblazeImportInstructionsWithHiddenFie
 }, {
     path: string | string[];
     robot: "/backblaze/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    recursive?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -225,10 +233,15 @@ export declare const interpolatableRobotBackblazeImportInstructionsWithHiddenFie
     bucket?: string | undefined;
     app_key_id?: string | undefined;
     app_key?: string | undefined;
-    recursive?: string | boolean | undefined;
     files_per_page?: string | number | undefined;
     start_file_name?: string | undefined;
 }>;
-export type InterpolatableRobotBackblazeImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotBackblazeImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotBackblazeImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotBackblazeImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotBackblazeImportInstructions = Instructions['output'];
+export type RobotBackblazeImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotBackblazeImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotBackblazeImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotBackblazeImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotBackblazeImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=backblaze-import.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"backblaze-import.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/backblaze-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAY1B,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BxC,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"}
+{"version":3,"file":"backblaze-import.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/backblaze-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAc1B,eAAO,MAAM,IAAI,EAAE,cAYlB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BxC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,sCAAsC,CAAC,KAAK,CACtC,CAAA;AAE3D,eAAO,MACa,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACxD,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAElE,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACrD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,gCAAgC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACrE,MAAM,MAAM,gDAAgD,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAC3F,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAChG,MAAM,MAAM,mDAAmD,GAC7D,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,8DAA8D,GACxE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,mEAAmE,GAC7E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}