@transloadit/zod 4.4.1 → 5.0.0

package/dist/v4/robots/file-watermark.js

@@ -1,51 +1,33 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, createRobotSchemaVariants, robotBase, robotImageProcessingMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 4,
-    discount_factor: 0.25,
-    discount_pct: 75,
-    example_code: {
-        steps: {
-            watermarked: {
-                robot: '/file/watermark',
-                use: ':original',
-                randomize: true,
-            },
-        },
-    },
+    ...robotImageProcessingMeta,
+    example_code: createProcessingExample('watermarked', '/file/watermark', {
+        randomize: true,
+    }),
     example_code_description: 'Apply randomized watermarking to uploaded files:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'Image Manipulation',
+    extended_description: `
+Watermarking is best effort. Unsupported file types, or files that cannot be processed, are returned unchanged. An Assembly can complete successfully without a watermark being applied.
+`,
     purpose_sentence: 'applies randomized watermarks to uploaded media',
     purpose_verb: 'write',
     purpose_word: 'watermark files',
     purpose_words: 'Watermark files',
-    service_slug: 'image-manipulation',
-    slot_count: 20,
     title: 'Apply watermarks to files',
     typical_file_size_mb: 1.2,
     typical_file_type: 'file',
     name: 'FileWatermarkRobot',
     priceFactor: 4,
     queueSlotCount: 20,
-    isAllowedForUrlTransform: true,
     trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotFileWatermarkInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/file/watermark'),
-    randomize: z.boolean().optional(),
+    randomize: optionalWithV3Semantics(z.boolean()),
 })
     .strict();
-export const robotFileWatermarkInstructionsWithHiddenFieldsSchema = robotFileWatermarkInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotFileWatermarkInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotFileWatermarkInstructionsSchema = interpolateRobot(robotFileWatermarkInstructionsSchema);
-export const interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileWatermarkInstructionsWithHiddenFieldsSchema);
+const schemaVariants = createRobotSchemaVariants(robotFileWatermarkInstructionsSchema);
+export const { withHiddenFields: robotFileWatermarkInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFileWatermarkInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema, } = schemaVariants;

package/dist/v4/robots/ftp-import.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 robotFtpImportInstructionsSchema: 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,17 @@ export declare const robotFtpImportInstructionsSchema: z.ZodObject<{
     path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     passive_mode: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotFtpImportInstructionsSchema.shape>;
 export declare const robotFtpImportInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -64,75 +67,77 @@ export declare const robotFtpImportInstructionsWithHiddenFieldsSchema: z.ZodObje
     path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     passive_mode: z.ZodDefault<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotFtpImportInstructions = z.infer<typeof robotFtpImportInstructionsSchema>;
-export type RobotFtpImportInstructionsWithHiddenFields = z.infer<typeof robotFtpImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFtpImportInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotFtpImportInstructionsSchema: 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>;
     password: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/ftp/import">;
     path: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>;
-    passive_mode: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotFtpImportInstructions = InterpolatableRobotFtpImportInstructionsInput;
-export type InterpolatableRobotFtpImportInstructionsInput = z.input<typeof interpolatableRobotFtpImportInstructionsSchema>;
-export declare const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    passive_mode: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>, interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema: 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>;
     password: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/ftp/import">;
     path: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>;
-    passive_mode: 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]>>]>>;
+    passive_mode: 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]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotFtpImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFtpImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotFtpImportInstructions = Instructions['output'];
+export type RobotFtpImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFtpImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFtpImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFtpImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFtpImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=ftp-import.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ftp-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/ftp-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,cAoClB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAelC,CAAA;AAEX,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGzD,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":"ftp-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/ftp-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAY1B,eAAO,MAAM,IAAI,EAAE,cAWlB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAelC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,gCAAgC,CAAC,KAAK,CACtC,CAAA;AAErD,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/ftp-import.js

@@ -1,39 +1,14 @@
 import { z } from 'zod/v4';
-import { ftpBase, interpolateRobot, path, robotBase, robotImport, } from "./_instructions-primitives.js";
+import { createStorageImportExample, defineRobot, ftpBase, path, robotBase, robotImport, robotImportMeta, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
-    example_code: {
-        steps: {
-            imported: {
-                robot: '/ftp/import',
-                credentials: 'YOUR_FTP_CREDENTIALS',
-                path: 'path/to/files/',
-            },
-        },
-    },
+    ...robotImportMeta,
+    example_code: createStorageImportExample('/ftp/import', 'YOUR_FTP_CREDENTIALS', false),
     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 FTP servers into Transloadit. This Robot relies on password access. For more security, consider our /sftp/import Robot',
-    purpose_verb: 'import',
     purpose_word: 'FTP servers',
     purpose_words: 'Import files from FTP servers',
-    service_slug: 'file-importing',
-    slot_count: 20,
     title: 'Import files from FTP servers',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'FtpImportRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 20,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-    stage: 'ga',
 };
 export const robotFtpImportInstructionsSchema = robotBase
     .merge(robotImport)
@@ -51,8 +26,5 @@ Determines if passive mode should be used for the FTP connection.
 `),
 })
     .strict();
-export const robotFtpImportInstructionsWithHiddenFieldsSchema = robotFtpImportInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotFtpImportInstructionsSchema.shape.result]).optional(),
-});
-export const interpolatableRobotFtpImportInstructionsSchema = interpolateRobot(robotFtpImportInstructionsSchema);
-export const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFtpImportInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotFtpImportInstructionsSchema);
+export const { withHiddenFields: robotFtpImportInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFtpImportInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v4/robots/ftp-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 robotFtpStoreInstructionsSchema: 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,22 @@ export declare const robotFtpStoreInstructionsSchema: z.ZodObject<{
     ssl_url_template: z.ZodDefault<z.ZodString>;
     secure: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
+declare const hiddenFields: {
+    use_remote_utime: z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    allowNetwork: z.ZodOptional<z.ZodString>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotFtpStoreInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: 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";
     }>>;
@@ -89,24 +97,22 @@ export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
     use_remote_utime: z.ZodOptional<z.ZodBoolean>;
     version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     allowNetwork: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type RobotFtpStoreInstructions = z.infer<typeof robotFtpStoreInstructionsSchema>;
-export type RobotFtpStoreInstructionsWithHiddenFields = z.infer<typeof robotFtpStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFtpStoreInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotFtpStoreInstructionsSchema: 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")[]>>]>>;
@@ -126,31 +132,29 @@ export declare const interpolatableRobotFtpStoreInstructionsSchema: 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>;
     password: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/ftp/store">;
-    path: z.ZodDefault<z.ZodString>;
-    url_template: z.ZodDefault<z.ZodString>;
-    ssl_url_template: z.ZodDefault<z.ZodString>;
-    secure: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotFtpStoreInstructions = InterpolatableRobotFtpStoreInstructionsInput;
-export type InterpolatableRobotFtpStoreInstructionsInput = z.input<typeof interpolatableRobotFtpStoreInstructionsSchema>;
-export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    path: z.ZodPrefault<z.ZodString>;
+    url_template: z.ZodPrefault<z.ZodString>;
+    ssl_url_template: z.ZodPrefault<z.ZodString>;
+    secure: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>, interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema: 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")[]>>]>>;
@@ -170,19 +174,25 @@ export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSche
     }, 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>;
     password: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/ftp/store">;
-    path: z.ZodDefault<z.ZodString>;
-    url_template: z.ZodDefault<z.ZodString>;
-    ssl_url_template: z.ZodDefault<z.ZodString>;
-    secure: 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]>>]>>;
+    path: z.ZodPrefault<z.ZodString>;
+    url_template: z.ZodPrefault<z.ZodString>;
+    ssl_url_template: z.ZodPrefault<z.ZodString>;
+    secure: 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]>>]>>;
     use_remote_utime: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     version: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber]>]>>;
     allowNetwork: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type InterpolatableRobotFtpStoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFtpStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotFtpStoreInstructions = Instructions['output'];
+export type RobotFtpStoreInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFtpStoreInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFtpStoreInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFtpStoreInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFtpStoreInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=ftp-store.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ftp-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/ftp-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgCjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgBxD,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":"ftp-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/ftp-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;AAW1B,eAAO,MAAM,IAAI,EAAE,cAUlB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgCjC,CAAA;AAEX,QAAA,MAAM,YAAY;;;;CAYjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,+BAA+B,CAAC,KAAK,EAC5C,OAAO,YAAY,CAC+D,CAAA;AAEpF,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/ftp-store.js

@@ -1,40 +1,15 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { ftpBase, interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createStorageStoreExample, defineRobotWithHiddenFields, ftpBase, robotBase, robotStoreMeta, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 6,
-    discount_factor: 0.15000150001500018,
-    discount_pct: 84.99984999849998,
-    example_code: {
-        steps: {
-            exported: {
-                robot: '/ftp/store',
-                use: ':original',
-                credentials: 'YOUR_FTP_CREDENTIALS',
-                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
-            },
-        },
-    },
+    ...robotStoreMeta,
+    example_code: createStorageStoreExample('/ftp/store', 'YOUR_FTP_CREDENTIALS'),
     example_code_description: 'Export uploaded files to `my_target_folder` on an FTP server:',
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Exporting',
     purpose_sentence: 'exports encoding results to your FTP servers. This Robot relies on password access. For more security, consider our /sftp/store Robot',
-    purpose_verb: 'export',
     purpose_word: 'FTP servers',
     purpose_words: 'Export files to FTP servers',
-    service_slug: 'file-exporting',
-    slot_count: 10,
     title: 'Export files to FTP servers',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'FtpStoreRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotFtpStoreInstructionsSchema = robotBase
     .merge(robotUse)
@@ -69,21 +44,18 @@ Determines whether to establish a secure connection to the FTP server using SSL.
 `),
 })
     .strict();
-export const robotFtpStoreInstructionsWithHiddenFieldsSchema = robotFtpStoreInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotFtpStoreInstructionsSchema.shape.result]).optional(),
-    use_remote_utime: z
-        .boolean()
-        .optional()
+const hiddenFields = {
+    use_remote_utime: optionalWithV3Semantics(z
+        .boolean())
         .describe(`
 Use the remote file's modification time instead of the current time when storing the file.
 `),
-    version: z
-        .union([z.string(), z.number()])
-        .optional()
+    version: optionalWithV3Semantics(z
+        .union([z.string(), z.number()]))
         .describe(`
 Version identifier for the underlying tool used (2 is ncftp, 1 is ftp).
 `),
-    allowNetwork: z.string().optional(), // For internal test purposes
-});
-export const interpolatableRobotFtpStoreInstructionsSchema = interpolateRobot(robotFtpStoreInstructionsSchema);
-export const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFtpStoreInstructionsWithHiddenFieldsSchema);
+    allowNetwork: optionalWithV3Semantics(z.string()), // For internal test purposes
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotFtpStoreInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotFtpStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFtpStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;