@transloadit/zod 4.5.0 → 5.0.0

package/dist/v4/robots/transloadit-import.js

@@ -1,6 +1,7 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
 import { damIdSchema } from "../storageAsset.js";
-import { booleanStringSchema, interpolateRobot, interpolationSchemaFull, recursive, robotBase, robotImport, } from "./_instructions-primitives.js";
+import { interpolateRobot, recursive, robotBase, robotImport } from "./_instructions-primitives.js";
 /** Cross-field validation runs after interpolation-aware parsing at the Assembly Step boundary. */
 export function refineTransloaditImportSelector(step, context) {
     if (step.robot !== '/transloadit/import')
@@ -26,10 +27,14 @@ const recursiveDescription = `
 Whether to import files from subfolders and sub-subfolders when \`path\` is a folder. By default
 only the folder's own files are imported.
 `;
+/** Storage imports require proof of possession independently of Workspace signature settings. */
+export const transloaditImportAuthenticationGuidanceLines = [
+    'Assemblies that use `/transloadit/import`, directly or through a Template, require',
+    'either a bearer token or signed `params` with a future `params.auth.expires` timestamp.',
+    'This applies even when Workspace Signature Authentication is disabled. An Auth Key alone',
+    'is not sufficient; bearer-authenticated requests do not need a separate signature or expiry.',
+];
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
     example_code: {
         steps: {
             imported: {
@@ -42,9 +47,7 @@ export const meta = {
     has_small_icon: true,
     isAllowedForUrlTransform: true,
     isInternal: false,
-    minimum_charge: 0,
     name: 'TransloaditImportRobot',
-    output_factor: 1,
     override_lvl1: 'File Importing',
     priceFactor: 10,
     purpose_sentence: 'imports files from Transloadit Storage',
@@ -54,7 +57,6 @@ export const meta = {
     queueSlotCount: 10,
     removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
     service_slug: 'file-importing',
-    slot_count: 10,
     stage: 'beta',
     title: 'Import files from Transloadit Storage',
     typical_file_size_mb: 1.2,
@@ -67,19 +69,20 @@ export const robotTransloaditImportInstructionsSchema = robotBase
 Imports files from your Workspace's Transloadit Storage. Select a mutable location with
 \`path\`, or a logical asset with \`asset_id\`. Add \`version_id\` to pin the exact stored bytes.
 IDs remain subject to Workspace access and version retention.
+
+${transloaditImportAuthenticationGuidanceLines.join('\n')}
 `),
-    path: z
-        .string()
-        .optional()
+    path: optionalWithV3Semantics(z
+        .string())
         .describe(`
 The current file or folder location, for example \`photos/cat.jpg\`. Use either \`path\` or
 \`asset_id\`, not both. Renaming makes an old path stale; overwriting changes what it imports.
 `),
-    asset_id: damIdSchema.optional().describe(`
+    asset_id: optionalWithV3Semantics(damIdSchema).describe(`
 The stored asset's stable ID. Without \`version_id\`, imports its current version even after
 renaming or moving it. Cannot be combined with \`path\` or recursive folder imports.
 `),
-    version_id: damIdSchema.optional().describe(`
+    version_id: optionalWithV3Semantics(damIdSchema).describe(`
 The exact retained version of \`asset_id\` to import. Requires \`asset_id\`; a missing or deleted
 version never falls back to the current version.
 `),
@@ -87,21 +90,13 @@ version never falls back to the current version.
 })
     .strict();
 export const robotTransloaditImportInstructionsWithHiddenFieldsSchema = robotTransloaditImportInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotTransloaditImportInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotTransloaditImportInstructionsSchema = interpolateRobot(robotTransloaditImportInstructionsSchema).extend({
-    // The generic boolean interpolator changes literal false to true. Keep Storage's documented
-    // false default intact; unresolved variables are validated after uploader interpolation.
-    recursive: z
-        .union([
-        recursive,
-        booleanStringSchema.transform((value) => value === 'true'),
-        interpolationSchemaFull,
-    ])
-        .describe(recursiveDescription),
-});
-export const interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTransloaditImportInstructionsWithHiddenFieldsSchema).extend({
-    recursive: interpolatableRobotTransloaditImportInstructionsSchema.shape.recursive,
+    result: optionalWithV3Semantics(z
+        .union([z.literal('debug'), robotTransloaditImportInstructionsSchema.shape.result])),
 });
+export const interpolatableRobotTransloaditImportInstructionsSchema = interpolateRobot(robotTransloaditImportInstructionsSchema);
+export const interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTransloaditImportInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = {
+    meta,
+    interpolatable: interpolatableRobotTransloaditImportInstructionsSchema,
+    interpolatableWithHiddenFields: interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema,
+};

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotTransloaditStoreInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -43,13 +44,14 @@ export declare const robotTransloaditStoreInstructionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const robotTransloaditStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -85,19 +87,20 @@ export type RobotTransloaditStoreInstructions = z.infer<typeof robotTransloaditS
 export type RobotTransloaditStoreInstructionsWithHiddenFields = z.infer<typeof robotTransloaditStoreInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotTransloaditStoreInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -116,29 +119,30 @@ export declare const interpolatableRobotTransloaditStoreInstructionsSchema: z.Zo
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/transloadit/store">;
-    conflict_strategy: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    conflict_strategy: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         error: "error";
         overwrite: "overwrite";
         rename: "rename";
     }>]>>;
-    path: z.ZodDefault<z.ZodString>;
+    path: z.ZodPrefault<z.ZodString>;
 }, z.core.$strict>;
 export type InterpolatableRobotTransloaditStoreInstructions = InterpolatableRobotTransloaditStoreInstructionsInput;
 export type InterpolatableRobotTransloaditStoreInstructionsInput = z.input<typeof interpolatableRobotTransloaditStoreInstructionsSchema>;
 export declare const interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -157,14 +161,15 @@ export declare const interpolatableRobotTransloaditStoreInstructionsWithHiddenFi
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/transloadit/store">;
-    conflict_strategy: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    conflict_strategy: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         error: "error";
         overwrite: "overwrite";
         rename: "rename";
     }>]>>;
-    path: z.ZodDefault<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    path: z.ZodPrefault<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 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/v4/robots/transloadit-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transloadit-store.d.ts","sourceRoot":"","sources":["../../../src/v4/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEjE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,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/v4/robots/transloadit-store.ts"],"names":[],"mappings":"AAEA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgCzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIhE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEjE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,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/v4/robots/transloadit-store.js

@@ -1,9 +1,7 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
 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 +14,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 +24,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 +35,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'])
@@ -60,9 +64,13 @@ are created.
 })
     .strict();
 export const robotTransloaditStoreInstructionsWithHiddenFieldsSchema = robotTransloaditStoreInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotTransloaditStoreInstructionsSchema.shape.result])
-        .optional(),
+    result: optionalWithV3Semantics(z
+        .union([z.literal('debug'), robotTransloaditStoreInstructionsSchema.shape.result])),
 });
 export const interpolatableRobotTransloaditStoreInstructionsSchema = interpolateRobot(robotTransloaditStoreInstructionsSchema);
 export const interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTransloaditStoreInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = {
+    meta,
+    interpolatable: interpolatableRobotTransloaditStoreInstructionsSchema,
+    interpolatableWithHiddenFields: interpolatableRobotTransloaditStoreInstructionsWithHiddenFieldsSchema,
+};

package/dist/v4/robots/tus-store.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotTusStoreInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -41,15 +42,17 @@ export declare const robotTusStoreInstructionsSchema: z.ZodObject<{
     url_template: z.ZodOptional<z.ZodString>;
     ssl_url_template: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotTusStoreInstructionsSchema.shape>;
 export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -80,24 +83,22 @@ export declare const robotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
     url_template: z.ZodOptional<z.ZodString>;
     ssl_url_template: z.ZodOptional<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotTusStoreInstructions = z.infer<typeof robotTusStoreInstructionsSchema>;
-export type RobotTusStoreInstructionsWithHiddenFields = z.infer<typeof robotTusStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -118,27 +119,25 @@ export declare const interpolatableRobotTusStoreInstructionsSchema: z.ZodObject<
     robot: z.ZodLiteral<"/tus/store">;
     endpoint: z.ZodString;
     credentials: z.ZodOptional<z.ZodString>;
-    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    metadata: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     url_template: z.ZodOptional<z.ZodString>;
     ssl_url_template: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type InterpolatableRobotTusStoreInstructions = InterpolatableRobotTusStoreInstructionsInput;
-export type InterpolatableRobotTusStoreInstructionsInput = z.input<typeof interpolatableRobotTusStoreInstructionsSchema>;
-export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotTusStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
     }>]>>;
-    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
@@ -159,12 +158,18 @@ export declare const interpolatableRobotTusStoreInstructionsWithHiddenFieldsSche
     robot: z.ZodLiteral<"/tus/store">;
     endpoint: z.ZodString;
     credentials: z.ZodOptional<z.ZodString>;
-    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    metadata: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     url_template: z.ZodOptional<z.ZodString>;
     ssl_url_template: z.ZodOptional<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-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/v4/robots/tus-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tus-store.d.ts","sourceRoot":"","sources":["../../../src/v4/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2CjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGxD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzE,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/v4/robots/tus-store.ts"],"names":[],"mappings":"AAEA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoCjC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,+BAA+B,CAAC,KAAK,CACtC,CAAA;AAEpD,eAAO,MACa,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACjD,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC7B,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC5E,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/v4/robots/tus-store.js

@@ -1,54 +1,28 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-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
-        .string()
-        .optional()
+    credentials: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Create <dfn>Template Credentials</dfn> for this <dfn>Robot</dfn> in your [Transloadit account](/c/template-credentials/) and use the name of the <dfn>Template Credentials</dfn> as this parameter's value. For this <dfn>Robot</dfn>, use the HTTP template, which allows request headers to be passed along to the destination server.
 `),
@@ -65,22 +39,17 @@ Although, we recommend to exclusively use <dfn>Template Credentials</dfn>, this
         .describe(`
 Metadata to pass along to destination. Includes some file info by default.
 `),
-    url_template: z
-        .string()
-        .optional()
+    url_template: optionalWithV3Semantics(z
+        .string())
         .describe(`
 The URL of the file in the <dfn>Assembly Status JSON</dfn>. The following [Assembly Variables](/docs/topics/assembly-instructions/#assembly-variables) are supported. If this is not specified, the upload URL specified by the destination server will be used instead.
 `),
-    ssl_url_template: z
-        .string()
-        .optional()
+    ssl_url_template: optionalWithV3Semantics(z
+        .string())
         .describe(`
 The SSL URL of the file in the <dfn>Assembly Status JSON</dfn>. The following [Assembly Variables](/docs/topics/assembly-instructions/#assembly-variables) are supported. If this is not specified, the upload URL specified by the destination server will be used instead, as long as it starts with \`https\`.
 `),
 })
     .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;