@transloadit/zod 4.5.0 → 5.0.1

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

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotTransloaditStoreInstructionsSchema: 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>;
@@ -63,12 +64,12 @@ export declare const robotTransloaditStoreInstructionsSchema: z.ZodObject<{
     path: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/transloadit/store";
     result: boolean;
+    robot: "/transloadit/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     conflict_strategy: "error" | "overwrite" | "rename";
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -83,12 +84,13 @@ export declare const robotTransloaditStoreInstructionsSchema: 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;
 }, {
     robot: "/transloadit/store";
     path?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -103,16 +105,18 @@ export declare const robotTransloaditStoreInstructionsSchema: 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;
     conflict_strategy?: "error" | "overwrite" | "rename" | undefined;
 }>;
 export declare const robotTransloaditStoreInstructionsWithHiddenFieldsSchema: 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")[]>>;
@@ -172,10 +176,11 @@ export declare const robotTransloaditStoreInstructionsWithHiddenFieldsSchema: z.
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/transloadit/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     conflict_strategy: "error" | "overwrite" | "rename";
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -190,13 +195,13 @@ export declare const robotTransloaditStoreInstructionsWithHiddenFieldsSchema: z.
         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;
 }, {
     robot: "/transloadit/store";
     path?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -211,8 +216,9 @@ export declare const robotTransloaditStoreInstructionsWithHiddenFieldsSchema: z.
         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;
@@ -221,8 +227,9 @@ export declare const robotTransloaditStoreInstructionsWithHiddenFieldsSchema: z.
 export type RobotTransloaditStoreInstructions = z.infer<typeof robotTransloaditStoreInstructionsSchema>;
 export type RobotTransloaditStoreInstructionsWithHiddenFields = z.infer<typeof robotTransloaditStoreInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotTransloaditStoreInstructionsSchema: 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.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]>>;
@@ -280,12 +287,12 @@ export declare const interpolatableRobotTransloaditStoreInstructionsSchema: z.Zo
     path: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/transloadit/store";
     result: string | boolean;
+    robot: "/transloadit/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     conflict_strategy: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -300,12 +307,13 @@ export declare const interpolatableRobotTransloaditStoreInstructionsSchema: z.Zo
         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;
 }, {
     robot: "/transloadit/store";
     path?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -320,8 +328,9 @@ export declare const interpolatableRobotTransloaditStoreInstructionsSchema: z.Zo
         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;
@@ -330,8 +339,9 @@ export declare const interpolatableRobotTransloaditStoreInstructionsSchema: z.Zo
 export type InterpolatableRobotTransloaditStoreInstructions = InterpolatableRobotTransloaditStoreInstructionsInput;
 export type InterpolatableRobotTransloaditStoreInstructionsInput = z.input<typeof interpolatableRobotTransloaditStoreInstructionsSchema>;
 export declare const interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema: 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.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")[]>]>>;
@@ -390,10 +400,11 @@ export declare const interpolatableRobotTransloaditStoreInstructionsWithHiddenFi
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/transloadit/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     conflict_strategy: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -408,13 +419,13 @@ export declare const interpolatableRobotTransloaditStoreInstructionsWithHiddenFi
         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;
 }, {
     robot: "/transloadit/store";
     path?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -429,8 +440,9 @@ export declare const interpolatableRobotTransloaditStoreInstructionsWithHiddenFi
         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;
@@ -438,4 +450,5 @@ export declare const interpolatableRobotTransloaditStoreInstructionsWithHiddenFi
 }>;
 export type InterpolatableRobotTransloaditStoreInstructionsWithHiddenFields = InterpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsInput;
 export type InterpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema>;
+export declare const robotDefinition: RobotSchemaPair<typeof interpolatableRobotTransloaditStoreInstructionsSchema, typeof interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema>;
 //# sourceMappingURL=transloadit-store.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transloadit-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/transloadit-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,cAkClB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GACzE,oEAAoE,CAAA;AACtE,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA"}
+{"version":3,"file":"transloadit-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/transloadit-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAEpF,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cA4BlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GACzE,oEAAoE,CAAA;AACtE,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,qDAAqD,EAC5D,OAAO,qEAAqE,CAM7E,CAAA"}

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

@@ -1,9 +1,6 @@
 import { z } from 'zod/v3';
 import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
     example_code: {
         steps: {
             stored: {
@@ -16,9 +13,7 @@ export const meta = {
     has_small_icon: true,
     isAllowedForUrlTransform: false,
     isInternal: false,
-    minimum_charge: 0,
     name: 'TransloaditStoreRobot',
-    output_factor: 1,
     override_lvl1: 'File Exporting',
     priceFactor: 10,
     purpose_sentence: 'stores files privately in Transloadit Storage',
@@ -28,7 +23,6 @@ export const meta = {
     queueSlotCount: 2,
     removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
     service_slug: 'file-exporting',
-    slot_count: 2,
     stage: 'beta',
     title: 'Store files in Transloadit Storage',
     trackOutputFileSize: true,
@@ -40,6 +34,15 @@ export const robotTransloaditStoreInstructionsSchema = robotBase
     .extend({
     robot: z.literal('/transloadit/store').describe(`
 Stores each input privately in Transloadit Storage.
+
+After \`ASSEMBLY_COMPLETED\`, save the stored result from \`results[producingStep][i]\` with
+your application's owner or project record. Keep its \`workspace\`, \`asset_id\`, \`version_id\` and returned \`path\`.
+A Step storing \`:original\` reports in \`results[':original']\`.
+
+Collisions fail by default; explicit renaming can change the final path. Use the asset and version
+IDs with 🤖/transloadit/import to reuse exact retained bytes after a native catalog rename or overwrite.
+A path selects the current location; an asset ID without a version selects its current bytes.
+Deleting an asset or removing a retained version makes that reference unavailable.
 `),
     conflict_strategy: z
         .enum(['error', 'overwrite', 'rename'])
@@ -66,3 +69,8 @@ export const robotTransloaditStoreInstructionsWithHiddenFieldsSchema = robotTran
 });
 export const interpolatableRobotTransloaditStoreInstructionsSchema = interpolateRobot(robotTransloaditStoreInstructionsSchema);
 export const interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTransloaditStoreInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = {
+    meta,
+    interpolatable: interpolatableRobotTransloaditStoreInstructionsSchema,
+    interpolatableWithHiddenFields: interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema,
+};

package/dist/v3/robots/tus-store.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 robotTusStoreInstructionsSchema: 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>;
@@ -59,21 +60,21 @@ export declare const robotTusStoreInstructionsSchema: z.ZodObject<{
     }>]>>;
 } & {
     robot: z.ZodLiteral<"/tus/store">;
-    endpoint: z.ZodString;
+    endpoint: z.ZodEffects<z.ZodString, string, string>;
     credentials: z.ZodOptional<z.ZodString>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     url_template: z.ZodOptional<z.ZodString>;
     ssl_url_template: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/tus/store";
     result: boolean;
+    robot: "/tus/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     headers: Record<string, string>;
     metadata: Record<string, string>;
     endpoint: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -88,6 +89,7 @@ export declare const robotTusStoreInstructionsSchema: 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;
@@ -96,7 +98,7 @@ export declare const robotTusStoreInstructionsSchema: z.ZodObject<{
 }, {
     robot: "/tus/store";
     endpoint: string;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -111,8 +113,9 @@ export declare const robotTusStoreInstructionsSchema: 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;
@@ -122,9 +125,11 @@ export declare const robotTusStoreInstructionsSchema: z.ZodObject<{
     url_template?: string | undefined;
     ssl_url_template?: string | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotTusStoreInstructionsSchema.shape>;
 export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: 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")[]>>;
@@ -177,7 +182,7 @@ export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/tus/store">;
-    endpoint: z.ZodString;
+    endpoint: z.ZodEffects<z.ZodString, string, string>;
     credentials: z.ZodOptional<z.ZodString>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -187,12 +192,13 @@ export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/tus/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     headers: Record<string, string>;
     metadata: Record<string, string>;
     endpoint: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -207,8 +213,8 @@ export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
         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;
     url_template?: string | undefined;
@@ -216,7 +222,7 @@ export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
 }, {
     robot: "/tus/store";
     endpoint: string;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -231,8 +237,9 @@ export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
         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;
@@ -241,12 +248,10 @@ export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
     metadata?: Record<string, string> | undefined;
     url_template?: string | undefined;
     ssl_url_template?: string | undefined;
-}>;
-export type RobotTusStoreInstructions = z.infer<typeof robotTusStoreInstructionsSchema>;
-export type RobotTusStoreInstructionsWithHiddenFields = z.infer<typeof robotTusStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotTusStoreInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotTusStoreInstructionsSchema: 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]>>;
@@ -300,21 +305,21 @@ export declare const interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/tus/store">;
-    endpoint: z.ZodString;
+    endpoint: z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodString, string, string>]>;
     credentials: z.ZodOptional<z.ZodString>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     url_template: z.ZodOptional<z.ZodString>;
     ssl_url_template: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/tus/store";
     result: string | boolean;
+    robot: "/tus/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     headers: Record<string, string>;
     metadata: Record<string, string>;
     endpoint: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -329,6 +334,7 @@ export declare const interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<
         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;
@@ -337,7 +343,7 @@ export declare const interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<
 }, {
     robot: "/tus/store";
     endpoint: string;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -352,8 +358,9 @@ export declare const interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<
         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;
@@ -362,12 +369,10 @@ export declare const interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<
     metadata?: Record<string, string> | undefined;
     url_template?: string | undefined;
     ssl_url_template?: string | undefined;
-}>;
-export type InterpolatableRobotTusStoreInstructions = InterpolatableRobotTusStoreInstructionsInput;
-export type InterpolatableRobotTusStoreInstructionsInput = z.input<typeof interpolatableRobotTusStoreInstructionsSchema>;
-export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema: 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")[]>]>>;
@@ -420,7 +425,7 @@ export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSche
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/tus/store">;
-    endpoint: z.ZodString;
+    endpoint: z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodString, string, string>]>;
     credentials: z.ZodOptional<z.ZodString>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -429,12 +434,13 @@ export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSche
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/tus/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     headers: Record<string, string>;
     metadata: Record<string, string>;
     endpoint: string;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -449,8 +455,8 @@ export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSche
         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;
     url_template?: string | undefined;
@@ -458,7 +464,7 @@ export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSche
 }, {
     robot: "/tus/store";
     endpoint: string;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -473,8 +479,9 @@ export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSche
         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;
@@ -484,6 +491,12 @@ export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSche
     url_template?: string | undefined;
     ssl_url_template?: string | undefined;
 }>;
-export type InterpolatableRobotTusStoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotTusStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotTusStoreInstructions = Instructions['output'];
+export type RobotTusStoreInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotTusStoreInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotTusStoreInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotTusStoreInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotTusStoreInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=tus-store.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tus-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/tus-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,cAkClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6CjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}
+{"version":3,"file":"tus-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/tus-store.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;AAW1B,eAAO,MAAM,IAAI,EAAE,cAYlB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCjC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,+BAA+B,CAAC,KAAK,CACtC,CAAA;AAEpD,eAAO,MACa,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACjD,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC7B,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC5E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,yBAAyB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAC9D,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACpF,MAAM,MAAM,uCAAuC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,uDAAuD,GACjE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,49 +1,23 @@
 import { z } from 'zod/v3';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobot, httpUrlSchema, robotBase, robotStoreMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
-    example_code: {
-        steps: {
-            exported: {
-                robot: '/tus/store',
-                use: ':original',
-                endpoint: 'https://tusd.tusdemo.net/files/',
-            },
-        },
-    },
+    ...robotStoreMeta,
+    example_code: createProcessingExample('exported', '/tus/store', {
+        endpoint: 'https://tusd.tusdemo.net/files/',
+    }),
     example_code_description: 'Export uploaded files to the Tus live demo server:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Exporting',
     purpose_sentence: 'exports encoding results to any Tus-compatible server',
-    purpose_verb: 'export',
     purpose_word: 'Tus servers',
     purpose_words: 'Export files to Tus-compatible servers',
-    service_slug: 'file-exporting',
-    slot_count: 10,
     title: 'Export files to Tus-compatible servers',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'TusStoreRobot',
     priceFactor: 10,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotTusStoreInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/tus/store'),
-    endpoint: z
-        .string()
-        .url()
-        .describe('The URL of the destination Tus server')
-        .describe(`
+    endpoint: httpUrlSchema.describe('The URL of the destination Tus server').describe(`
 The URL of the Tus-compatible server, which you're uploading files to.
 `),
     credentials: z
@@ -81,8 +55,5 @@ The SSL URL of the file in the <dfn>Assembly Status JSON</dfn>. The following [A
 `),
 })
     .strict();
-export const robotTusStoreInstructionsWithHiddenFieldsSchema = robotTusStoreInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotTusStoreInstructionsSchema.shape.result]).optional(),
-});
-export const interpolatableRobotTusStoreInstructionsSchema = interpolateRobot(robotTusStoreInstructionsSchema);
-export const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTusStoreInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotTusStoreInstructionsSchema);
+export const { withHiddenFields: robotTusStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotTusStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;