@transloadit/zod 4.5.0 → 5.0.0

package/dist/v3/robots/ftp-import.js

@@ -1,39 +1,14 @@
 import { z } from 'zod/v3';
-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/v3/robots/ftp-store.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotFtpStoreInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -71,15 +72,16 @@ export declare const robotFtpStoreInstructionsSchema: z.ZodObject<{
     secure: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/ftp/store";
     result: boolean;
+    robot: "/ftp/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     port: number;
     url_template: string;
     ssl_url_template: string;
     secure: boolean;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -94,16 +96,17 @@ export declare const robotFtpStoreInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     password?: string | undefined;
 }, {
     robot: "/ftp/store";
     path?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -118,13 +121,13 @@ export declare const robotFtpStoreInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     port?: number | undefined;
     password?: string | undefined;
@@ -132,9 +135,16 @@ export declare const robotFtpStoreInstructionsSchema: z.ZodObject<{
     ssl_url_template?: string | undefined;
     secure?: boolean | undefined;
 }>;
+declare const hiddenFields: {
+    use_remote_utime: z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodOptional<z.ZodUnion<[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<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>>;
@@ -204,6 +214,7 @@ export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/ftp/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     port: number;
@@ -211,7 +222,8 @@ export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
     ssl_url_template: string;
     secure: boolean;
     version?: string | number | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -226,11 +238,10 @@ export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     password?: string | undefined;
     use_remote_utime?: boolean | undefined;
@@ -239,7 +250,8 @@ export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
     robot: "/ftp/store";
     path?: string | undefined;
     version?: string | number | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -254,13 +266,13 @@ export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     port?: number | undefined;
     password?: string | undefined;
@@ -269,12 +281,10 @@ export declare const robotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObjec
     secure?: boolean | undefined;
     use_remote_utime?: boolean | undefined;
     allowNetwork?: string | undefined;
-}>;
-export type RobotFtpStoreInstructions = z.infer<typeof robotFtpStoreInstructionsSchema>;
-export type RobotFtpStoreInstructionsWithHiddenFields = z.infer<typeof robotFtpStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFtpStoreInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotFtpStoreInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -339,15 +349,16 @@ export declare const interpolatableRobotFtpStoreInstructionsSchema: z.ZodObject<
     secure: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/ftp/store";
     result: string | boolean;
+    robot: "/ftp/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     port: string | number;
     url_template: string;
     ssl_url_template: string;
     secure: string | boolean;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -362,16 +373,17 @@ export declare const interpolatableRobotFtpStoreInstructionsSchema: z.ZodObject<
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     password?: string | undefined;
 }, {
     robot: "/ftp/store";
     path?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -386,25 +398,23 @@ export declare const interpolatableRobotFtpStoreInstructionsSchema: z.ZodObject<
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     port?: string | number | undefined;
     password?: string | undefined;
     url_template?: string | undefined;
     ssl_url_template?: string | undefined;
     secure?: string | boolean | undefined;
-}>;
-export type InterpolatableRobotFtpStoreInstructions = InterpolatableRobotFtpStoreInstructionsInput;
-export type InterpolatableRobotFtpStoreInstructionsInput = z.input<typeof interpolatableRobotFtpStoreInstructionsSchema>;
-export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "execute"]>, "many">]>, string[], boolean | ("meta" | "execute")[]>]>>;
@@ -473,6 +483,7 @@ export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSche
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/ftp/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     port: string | number;
@@ -480,7 +491,8 @@ export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSche
     ssl_url_template: string;
     secure: string | boolean;
     version?: string | number | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -495,11 +507,10 @@ export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSche
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     password?: string | undefined;
     use_remote_utime?: string | boolean | undefined;
@@ -508,7 +519,8 @@ export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSche
     robot: "/ftp/store";
     path?: string | undefined;
     version?: string | number | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
+    user?: string | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -523,13 +535,13 @@ export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSche
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
     credentials?: string | undefined;
-    user?: string | undefined;
     host?: string | undefined;
     port?: string | number | undefined;
     password?: string | undefined;
@@ -539,6 +551,12 @@ export declare const interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSche
     use_remote_utime?: string | boolean | undefined;
     allowNetwork?: string | undefined;
 }>;
-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/v3/robots/ftp-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ftp-store.d.ts","sourceRoot":"","sources":["../../../src/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}
+{"version":3,"file":"ftp-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/ftp-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAUlB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCjC,CAAA;AAEX,QAAA,MAAM,YAAY;;;;CAcjB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACjD,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC7B,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC5E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,yBAAyB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAC9D,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACpF,MAAM,MAAM,uCAAuC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,uDAAuD,GACjE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,40 +1,14 @@
 import { z } from 'zod/v3';
-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,8 +43,7 @@ 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(),
+const hiddenFields = {
     use_remote_utime: z
         .boolean()
         .optional()
@@ -84,6 +57,6 @@ Use the remote file's modification time instead of the current time when storing
 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);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotFtpStoreInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotFtpStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFtpStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFtpStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;

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

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotGoogleImportInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -21,13 +22,14 @@ export declare const robotGoogleImportInstructionsSchema: z.ZodObject<{
     files_per_page: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/google/import";
     result: boolean;
+    robot: "/google/import";
+    recursive: boolean;
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     next_page_token: string;
     files_per_page: number;
     interpolate?: boolean | Record<string, boolean> | undefined;
@@ -37,22 +39,25 @@ export declare const robotGoogleImportInstructionsSchema: z.ZodObject<{
 }, {
     path: string | string[];
     robot: "/google/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
+    recursive?: boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: "meta"[] | undefined;
     credentials?: string | undefined;
-    recursive?: boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: number | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotGoogleImportInstructionsSchema.shape>;
 export declare const robotGoogleImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
@@ -69,39 +74,39 @@ export declare const robotGoogleImportInstructionsWithHiddenFieldsSchema: z.ZodO
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/google/import";
+    recursive: boolean;
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     next_page_token: string;
     files_per_page: number;
+    result?: boolean | "debug" | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
 }, {
     path: string | string[];
     robot: "/google/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
+    recursive?: boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: "meta"[] | undefined;
     credentials?: string | undefined;
-    recursive?: boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: number | undefined;
-}>;
-export type RobotGoogleImportInstructions = z.infer<typeof robotGoogleImportInstructionsSchema>;
-export type RobotGoogleImportInstructionsWithHiddenFields = z.infer<typeof robotGoogleImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotGoogleImportInstructionsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotGoogleImportInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -116,13 +121,14 @@ export declare const interpolatableRobotGoogleImportInstructionsSchema: z.ZodObj
     files_per_page: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/google/import";
     result: string | boolean;
+    robot: "/google/import";
+    recursive: string | boolean;
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     next_page_token: string;
     files_per_page: string | number;
     interpolate?: boolean | Record<string, boolean> | undefined;
@@ -132,24 +138,23 @@ export declare const interpolatableRobotGoogleImportInstructionsSchema: z.ZodObj
 }, {
     path: string | string[];
     robot: "/google/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    recursive?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: string | string[] | undefined;
     credentials?: string | undefined;
-    recursive?: string | boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: string | number | undefined;
-}>;
-export type InterpolatableRobotGoogleImportInstructions = InterpolatableRobotGoogleImportInstructionsInput;
-export type InterpolatableRobotGoogleImportInstructionsInput = z.input<typeof interpolatableRobotGoogleImportInstructionsSchema>;
-export declare const interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
-    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
+}>, interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "true" | "false">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
@@ -165,34 +170,42 @@ export declare const interpolatableRobotGoogleImportInstructionsWithHiddenFields
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/google/import";
+    recursive: string | boolean;
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     next_page_token: string;
     files_per_page: string | number;
+    result?: string | boolean | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
 }, {
     path: string | string[];
     robot: "/google/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    recursive?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: string | string[] | undefined;
     credentials?: string | undefined;
-    recursive?: string | boolean | undefined;
     next_page_token?: string | undefined;
     files_per_page?: string | number | undefined;
 }>;
-export type InterpolatableRobotGoogleImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotGoogleImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotGoogleImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotGoogleImportInstructions = Instructions['output'];
+export type RobotGoogleImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotGoogleImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotGoogleImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotGoogleImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=google-import.d.ts.map