@transloadit/zod 4.5.0 → 5.0.0

package/dist/v4/robots/script-run.js

@@ -1,39 +1,23 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobotWithHiddenFields, robotBase, robotCodeEvaluationMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
-    example_code: {
-        steps: {
-            evaluate: {
-                robot: '/script/run',
-                use: ':original',
-                script: '({ width: file.meta.width, height: file.meta.height, area: file.meta.width * file.meta.height })',
-            },
-        },
-    },
+    ...robotCodeEvaluationMeta,
+    example_code: createProcessingExample('evaluate', '/script/run', {
+        script: '({ width: file.meta.width, height: file.meta.height, area: file.meta.width * file.meta.height })',
+    }),
     example_code_description: 'Run JavaScript against uploaded file metadata:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'Code Evaluation',
     purpose_sentence: 'runs scripts in Assemblies',
     purpose_verb: 'run',
     purpose_word: 'script',
     purpose_words: 'Run scripts in Assemblies',
-    service_slug: 'code-evaluation',
-    slot_count: 5,
     title: 'Run Scripts',
     typical_file_size_mb: 0.0001,
-    typical_file_type: 'file',
     name: 'ScriptRunRobot',
     priceFactor: 10,
     queueSlotCount: 5,
     isAllowedForUrlTransform: true,
     trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotScriptRunInstructionsSchema = robotBase
     .merge(robotUse)
@@ -90,14 +74,12 @@ You can check whether evaluating this script was free by inspecting \`file.meta.
 `),
 })
     .strict();
-export const robotScriptRunInstructionsWithHiddenFieldsSchema = robotScriptRunInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotScriptRunInstructionsSchema.shape.result]).optional(),
-    contextJSON: z
-        .string()
-        .optional()
+const hiddenFields = {
+    contextJSON: optionalWithV3Semantics(z
+        .string())
         .describe(`
 A JSON string that provides additional context data to the script. This will be parsed and made available to the script as a \`context\` variable. For example, if you pass \`'{"foo":{"bar":"baz"}}'\`, the script can access \`context.foo.bar\` to get the value \`"baz"\`.
 `),
-});
-export const interpolatableRobotScriptRunInstructionsSchema = interpolateRobot(robotScriptRunInstructionsSchema);
-export const interpolatableRobotScriptRunInstructionsWithHiddenFieldsSchema = interpolateRobot(robotScriptRunInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotScriptRunInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotScriptRunInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotScriptRunInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotScriptRunInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/sftp-import.d.ts

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotSftpImportInstructionsSchema: 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";
@@ -33,15 +34,20 @@ export declare const robotSftpImportInstructionsSchema: z.ZodObject<{
     path: z.ZodString;
     recursive: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
+declare const hiddenFields: {
+    allowNetwork: z.ZodOptional<z.ZodString>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotSftpImportInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotSftpImportInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -65,76 +71,78 @@ export declare const robotSftpImportInstructionsWithHiddenFieldsSchema: z.ZodObj
     recursive: z.ZodDefault<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
     allowNetwork: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type RobotSftpImportInstructions = z.infer<typeof robotSftpImportInstructionsSchema>;
-export type RobotSftpImportInstructionsWithHiddenFields = z.infer<typeof robotSftpImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotSftpImportInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotSftpImportInstructionsSchema: 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]>>;
-    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
-    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]>>;
+    force_name: z.ZodPrefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         import: "import";
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
-    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    import_on_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
     }>]>>]>>;
     credentials: z.ZodOptional<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
-    port: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    port: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     user: z.ZodOptional<z.ZodString>;
     public_key: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/sftp/import">;
     path: z.ZodString;
-    recursive: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotSftpImportInstructions = InterpolatableRobotSftpImportInstructionsInput;
-export type InterpolatableRobotSftpImportInstructionsInput = z.input<typeof interpolatableRobotSftpImportInstructionsSchema>;
-export declare const interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    recursive: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>, interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema: 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]>>;
-    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
-    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]>>;
+    force_name: z.ZodPrefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
+    ignore_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
         import: "import";
         meta: "meta";
         execute: "execute";
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
-    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    import_on_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
     }>]>>]>>;
     credentials: z.ZodOptional<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
-    port: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    port: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     user: z.ZodOptional<z.ZodString>;
     public_key: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/sftp/import">;
     path: z.ZodString;
-    recursive: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    recursive: z.ZodPrefault<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]>>]>>;
     allowNetwork: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type InterpolatableRobotSftpImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotSftpImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotSftpImportInstructions = Instructions['output'];
+export type RobotSftpImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotSftpImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotSftpImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotSftpImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotSftpImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=sftp-import.d.ts.map

package/dist/v4/robots/sftp-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sftp-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/sftp-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAW1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,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":"sftp-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/sftp-import.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAY1B,eAAO,MAAM,IAAI,EAAE,cAWlB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYnC,CAAA;AAEX,QAAA,MAAM,YAAY;;CAMjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,iCAAiC,CAAC,KAAK,EAC9C,OAAO,YAAY,CACiE,CAAA;AAEtF,eAAO,MACa,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACnD,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC/B,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC9E,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/v4/robots/sftp-import.js

@@ -1,40 +1,15 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, recursive, robotBase, robotImport, sftpBase, } from "./_instructions-primitives.js";
+import { createStorageImportExample, defineRobotWithHiddenFields, recursive, robotBase, robotImport, robotImportMeta, sftpBase, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
-    example_code: {
-        steps: {
-            imported: {
-                robot: '/sftp/import',
-                credentials: 'YOUR_SFTP_CREDENTIALS',
-                path: 'path/to/files/',
-                recursive: true,
-            },
-        },
-    },
+    ...robotImportMeta,
+    example_code: createStorageImportExample('/sftp/import', 'YOUR_SFTP_CREDENTIALS'),
     example_code_description: 'Import files from the `path/to/files` directory and its subdirectories:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Importing',
     purpose_sentence: 'imports whole libraries of files from your SFTP servers into Transloadit. This Robot relies on public key authentication',
-    purpose_verb: 'import',
     purpose_word: 'SFTP servers',
     purpose_words: 'Import files from SFTP servers',
-    service_slug: 'file-importing',
-    slot_count: 20,
     title: 'Import files from SFTP servers',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'SftpImportRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 20,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-    stage: 'ga',
 };
 export const robotSftpImportInstructionsSchema = robotBase
     .merge(robotImport)
@@ -49,16 +24,12 @@ Setting this to \`true\` will enable importing files from subdirectories and sub
 `),
 })
     .strict();
-export const robotSftpImportInstructionsWithHiddenFieldsSchema = robotSftpImportInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotSftpImportInstructionsSchema.shape.result])
-        .optional(),
-    allowNetwork: z
-        .string()
-        .optional()
+const hiddenFields = {
+    allowNetwork: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Network access permission for the SFTP connection. This is used to control which networks the SFTP robot can access.
 `),
-});
-export const interpolatableRobotSftpImportInstructionsSchema = interpolateRobot(robotSftpImportInstructionsSchema);
-export const interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotSftpImportInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotSftpImportInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotSftpImportInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotSftpImportInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema, } = robotDefinition;

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotSftpStoreInstructionsSchema: 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";
@@ -44,15 +45,20 @@ export declare const robotSftpStoreInstructionsSchema: z.ZodObject<{
     ssl_url_template: z.ZodDefault<z.ZodString>;
     file_chmod: z.ZodDefault<z.ZodString>;
 }, z.core.$strict>;
+declare const hiddenFields: {
+    allowNetwork: z.ZodOptional<z.ZodString>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotSftpStoreInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotSftpStoreInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -87,24 +93,22 @@ export declare const robotSftpStoreInstructionsWithHiddenFieldsSchema: z.ZodObje
     file_chmod: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
     allowNetwork: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type RobotSftpStoreInstructions = z.infer<typeof robotSftpStoreInstructionsSchema>;
-export type RobotSftpStoreInstructionsWithHiddenFields = z.infer<typeof robotSftpStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotSftpStoreInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotSftpStoreInstructionsSchema: 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")[]>>]>>;
@@ -124,31 +128,29 @@ export declare const interpolatableRobotSftpStoreInstructionsSchema: z.ZodObject
     }, z.core.$strict>]>>;
     credentials: z.ZodOptional<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
-    port: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    port: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     user: z.ZodOptional<z.ZodString>;
     public_key: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/sftp/store">;
-    path: z.ZodDefault<z.ZodString>;
-    url_template: z.ZodDefault<z.ZodString>;
-    ssl_url_template: z.ZodDefault<z.ZodString>;
-    file_chmod: z.ZodDefault<z.ZodString>;
-}, z.core.$strict>;
-export type InterpolatableRobotSftpStoreInstructions = InterpolatableRobotSftpStoreInstructionsInput;
-export type InterpolatableRobotSftpStoreInstructionsInput = z.input<typeof interpolatableRobotSftpStoreInstructionsSchema>;
-export declare const interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    path: z.ZodPrefault<z.ZodString>;
+    url_template: z.ZodPrefault<z.ZodString>;
+    ssl_url_template: z.ZodPrefault<z.ZodString>;
+    file_chmod: z.ZodPrefault<z.ZodString>;
+}, z.core.$strict>, interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -168,17 +170,23 @@ export declare const interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSch
     }, z.core.$strict>]>>;
     credentials: z.ZodOptional<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
-    port: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    port: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     user: z.ZodOptional<z.ZodString>;
     public_key: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/sftp/store">;
-    path: z.ZodDefault<z.ZodString>;
-    url_template: z.ZodDefault<z.ZodString>;
-    ssl_url_template: z.ZodDefault<z.ZodString>;
-    file_chmod: 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>;
+    url_template: z.ZodPrefault<z.ZodString>;
+    ssl_url_template: z.ZodPrefault<z.ZodString>;
+    file_chmod: 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]>>]>>;
     allowNetwork: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type InterpolatableRobotSftpStoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotSftpStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotSftpStoreInstructions = Instructions['output'];
+export type RobotSftpStoreInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotSftpStoreInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotSftpStoreInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotSftpStoreInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotSftpStoreInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=sftp-store.d.ts.map

package/dist/v4/robots/sftp-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sftp-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/sftp-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,cAmClB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+BlC,CAAA;AAEX,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASzD,CAAA;AAEJ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACzF,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAC9D,OAAO,gDAAgD,CACxD,CAAA;AAED,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1D,CAAA;AACD,MAAM,MAAM,wCAAwC,GAAG,6CAA6C,CAAA;AAEpG,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,8CAA8C,CACtD,CAAA;AAED,eAAO,MAAM,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1E,CAAA;AACD,MAAM,MAAM,wDAAwD,GAAG,CAAC,CAAC,KAAK,CAC5E,OAAO,8DAA8D,CACtE,CAAA;AACD,MAAM,MAAM,6DAA6D,GAAG,CAAC,CAAC,KAAK,CACjF,OAAO,8DAA8D,CACtE,CAAA"}
+{"version":3,"file":"sftp-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/sftp-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAY1B,eAAO,MAAM,IAAI,EAAE,cASlB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BlC,CAAA;AAEX,QAAA,MAAM,YAAY;;CAMjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,gCAAgC,CAAC,KAAK,EAC7C,OAAO,YAAY,CACgE,CAAA;AAErF,eAAO,MACa,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAClD,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC9B,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC7E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,0BAA0B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAC/D,MAAM,MAAM,0CAA0C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACrF,MAAM,MAAM,wCAAwC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC1F,MAAM,MAAM,6CAA6C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC/F,MAAM,MAAM,wDAAwD,GAClE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,6DAA6D,GACvE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v4/robots/sftp-store.js

@@ -1,52 +1,22 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse, sftpBase } from "./_instructions-primitives.js";
+import { createStorageStoreExample, defineRobotWithHiddenFields, robotBase, robotStoreMeta, robotUse, sftpBase, storePath, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 6,
-    discount_factor: 0.15000150001500018,
-    discount_pct: 84.99984999849998,
-    example_code: {
-        steps: {
-            exported: {
-                robot: '/sftp/store',
-                use: ':original',
-                credentials: 'YOUR_SFTP_CREDENTIALS',
-                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
-            },
-        },
-    },
+    ...robotStoreMeta,
+    example_code: createStorageStoreExample('/sftp/store', 'YOUR_SFTP_CREDENTIALS'),
     example_code_description: 'Export uploaded files to `my_target_folder` on an SFTP server:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Exporting',
     purpose_sentence: 'exports encoding results to your own SFTP server',
-    purpose_verb: 'export',
     purpose_word: 'SFTP servers',
     purpose_words: 'Export files to SFTP servers',
-    service_slug: 'file-exporting',
-    slot_count: 10,
     title: 'Export files to SFTP servers',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'SftpStoreRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotSftpStoreInstructionsSchema = robotBase
     .merge(robotUse)
     .merge(sftpBase)
     .extend({
     robot: z.literal('/sftp/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,
     url_template: z
         .string()
         .default('http://host/path')
@@ -61,21 +31,19 @@ The URL of the file in the result JSON. This may include any of the following su
 `),
     file_chmod: z
         .string()
-        .regex(/([0-7]{3}|auto)/)
+        .regex(/([0-7]{3}|auto)/u)
         .default('auto')
         .describe(`
 This optional parameter controls how an uploaded file's permission bits are set. You can use any string format that the \`chmod\` command would accept, such as \`"755"\`. If you don't specify this option, the file's permission bits aren't changed at all, meaning it's up to your server's configuration (e.g. umask).
       `),
 })
     .strict();
-export const robotSftpStoreInstructionsWithHiddenFieldsSchema = robotSftpStoreInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotSftpStoreInstructionsSchema.shape.result]).optional(),
-    allowNetwork: z
-        .string()
-        .optional()
+const hiddenFields = {
+    allowNetwork: optionalWithV3Semantics(z
+        .string())
         .describe(`
 Network access permission for the SFTP connection. This is used to control which networks the SFTP robot can access.
 `),
-});
-export const interpolatableRobotSftpStoreInstructionsSchema = interpolateRobot(robotSftpStoreInstructionsSchema);
-export const interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotSftpStoreInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotSftpStoreInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotSftpStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotSftpStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotSftpStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;