transloadit 4.14.0 → 5.0.0

package/dist/alphalib/types/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';
 export declare const meta: RobotMetaInput;
 export declare const robotFtpImportInstructionsSchema: 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">>]>>;
     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>;
 } & {
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
-    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>>;
     import_on_errors: z.ZodDefault<z.ZodArray<z.ZodEnum<["meta"]>, "many">>;
 } & {
     credentials: z.ZodOptional<z.ZodString>;
@@ -24,6 +25,7 @@ export declare const robotFtpImportInstructionsSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     port: number;
+    user_meta: Record<string, unknown>;
     robot: "/ftp/import";
     result: boolean;
     force_accept: boolean;
@@ -33,9 +35,9 @@ export declare const robotFtpImportInstructionsSchema: z.ZodObject<{
     passive_mode: boolean;
     host?: string | undefined;
     password?: string | undefined;
+    queue?: "batch" | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    queue?: "batch" | undefined;
     credentials?: string | undefined;
     user?: string | undefined;
 }, {
@@ -44,25 +46,28 @@ export declare const robotFtpImportInstructionsSchema: z.ZodObject<{
     host?: string | undefined;
     port?: number | undefined;
     password?: string | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
-    queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
-    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: "meta"[] | undefined;
     credentials?: string | undefined;
     user?: string | undefined;
     passive_mode?: boolean | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotFtpImportInstructionsSchema.shape>;
 export declare const robotFtpImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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">]>>>;
-    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>>;
     import_on_errors: z.ZodDefault<z.ZodArray<z.ZodEnum<["meta"]>, "many">>;
     credentials: z.ZodOptional<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
@@ -77,6 +82,7 @@ export declare const robotFtpImportInstructionsWithHiddenFieldsSchema: z.ZodObje
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     port: number;
+    user_meta: Record<string, unknown>;
     robot: "/ftp/import";
     force_accept: boolean;
     ignore_errors: string[];
@@ -85,10 +91,10 @@ export declare const robotFtpImportInstructionsWithHiddenFieldsSchema: z.ZodObje
     passive_mode: boolean;
     host?: string | undefined;
     password?: string | undefined;
+    queue?: "batch" | 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;
 }, {
@@ -97,28 +103,27 @@ export declare const robotFtpImportInstructionsWithHiddenFieldsSchema: z.ZodObje
     host?: string | undefined;
     port?: number | undefined;
     password?: string | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: "batch" | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
-    queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
-    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: "meta"[] | undefined;
     credentials?: string | undefined;
     user?: string | undefined;
     passive_mode?: boolean | undefined;
-}>;
-export type RobotFtpImportInstructions = z.infer<typeof robotFtpImportInstructionsSchema>;
-export type RobotFtpImportInstructionsWithHiddenFields = z.infer<typeof robotFtpImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFtpImportInstructionsSchema: z.ZodObject<{
+}>, interpolatableRobotFtpImportInstructionsSchema: 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">>]>>;
     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]>>;
     force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>]>>;
     import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<["meta"]>]>, "many">]>>;
     credentials: z.ZodOptional<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
@@ -131,6 +136,7 @@ export declare const interpolatableRobotFtpImportInstructionsSchema: z.ZodObject
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     port: string | number;
+    user_meta: Record<string, unknown>;
     robot: "/ftp/import";
     result: string | boolean;
     force_accept: string | boolean;
@@ -140,9 +146,9 @@ export declare const interpolatableRobotFtpImportInstructionsSchema: z.ZodObject
     passive_mode: string | boolean;
     host?: string | undefined;
     password?: string | undefined;
+    queue?: string | 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;
 }, {
@@ -151,27 +157,26 @@ export declare const interpolatableRobotFtpImportInstructionsSchema: z.ZodObject
     host?: string | undefined;
     port?: string | number | undefined;
     password?: string | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
-    queue?: string | undefined;
     force_accept?: string | boolean | undefined;
-    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: string | boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: string | string[] | undefined;
     credentials?: string | undefined;
     user?: string | undefined;
     passive_mode?: string | boolean | undefined;
-}>;
-export type InterpolatableRobotFtpImportInstructions = InterpolatableRobotFtpImportInstructionsInput;
-export type InterpolatableRobotFtpImportInstructionsInput = z.input<typeof interpolatableRobotFtpImportInstructionsSchema>;
-export declare const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}>, interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
     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">]>]>>>;
-    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("meta" | "import" | "execute")[]>]>>;
     import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<["meta"]>]>, "many">]>>;
     credentials: z.ZodOptional<z.ZodString>;
     host: z.ZodOptional<z.ZodString>;
@@ -185,6 +190,7 @@ export declare const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSch
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     port: string | number;
+    user_meta: Record<string, unknown>;
     robot: "/ftp/import";
     force_accept: string | boolean;
     ignore_errors: string | string[];
@@ -193,10 +199,10 @@ export declare const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSch
     passive_mode: string | boolean;
     host?: string | undefined;
     password?: string | undefined;
+    queue?: string | 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;
 }, {
@@ -205,18 +211,25 @@ export declare const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSch
     host?: string | undefined;
     port?: string | number | undefined;
     password?: string | undefined;
+    user_meta?: Record<string, unknown> | undefined;
+    queue?: string | undefined;
     interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
-    queue?: string | undefined;
     force_accept?: string | boolean | undefined;
-    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    ignore_errors?: string | boolean | ("meta" | "import" | "execute")[] | undefined;
     force_name?: string | string[] | null | undefined;
     import_on_errors?: string | string[] | undefined;
     credentials?: string | undefined;
     user?: string | undefined;
     passive_mode?: string | boolean | undefined;
 }>;
-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/alphalib/types/robots/ftp-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ftp-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/ftp-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAelC,CAAA;AAEX,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGzD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE1E,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/alphalib/types/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,KAAK,CAAA;AAYvB,eAAO,MAAM,IAAI,EAAE,cAWlB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAelC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,gCAAgC,CAAC,KAAK,CACtC,CAAA;AAErD,eAAO,MACa,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAClD,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC9B,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC7E,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/alphalib/types/robots/ftp-import.js

@@ -1,39 +1,14 @@
 import { z } from 'zod';
-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,9 +26,6 @@ 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;
 //# sourceMappingURL=ftp-import.js.map

package/dist/alphalib/types/robots/ftp-import.js.map

@@ -1 +1 @@
-{"version":3,"file":"ftp-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/ftp-import.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,IAAI,EACJ,SAAS,EACT,WAAW,GACZ,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,UAAU,EAAE,EAAE;IACd,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,EAAE;IAChB,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,aAAa;gBACpB,WAAW,EAAE,sBAAsB;gBACnC,IAAI,EAAE,gBAAgB;aACvB;SACF;KACF;IACD,wBAAwB,EACtB,yEAAyE;IAC3E,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EACd,mKAAmK;IACrK,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,aAAa;IAC3B,aAAa,EAAE,+BAA+B;IAC9C,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,+BAA+B;IACtC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;IACzB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EAAE,MAAM;IACnB,cAAc,EAAE,EAAE;IAClB,wBAAwB,EAAE,IAAI;IAC9B,mBAAmB,EAAE,KAAK;IAC1B,UAAU,EAAE,KAAK;IACjB,iDAAiD,EAAE,IAAI;IACvD,KAAK,EAAE,IAAI;CACZ,CAAA;AAED,MAAM,CAAC,MAAM,gCAAgC,GAAG,SAAS;KACtD,KAAK,CAAC,WAAW,CAAC;KAClB,KAAK,CAAC,OAAO,CAAC;KACd,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC/B,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC;;CAEvB,CAAC;IACE,YAAY,EAAE,CAAC;SACZ,OAAO,EAAE;SACT,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CAAC;;CAEf,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,gDAAgD,GAC3D,gCAAgC,CAAC,MAAM,CAAC;IACtC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,gCAAgC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;CAChG,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,8CAA8C,GAAG,gBAAgB,CAC5E,gCAAgC,CACjC,CAAA;AAOD,MAAM,CAAC,MAAM,8DAA8D,GAAG,gBAAgB,CAC5F,gDAAgD,CACjD,CAAA"}
+{"version":3,"file":"ftp-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/ftp-import.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EACL,0BAA0B,EAC1B,WAAW,EACX,OAAO,EACP,IAAI,EACJ,SAAS,EACT,WAAW,EACX,eAAe,GAChB,MAAM,+BAA+B,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,GAAG,eAAe;IAClB,YAAY,EAAE,0BAA0B,CAAC,aAAa,EAAE,sBAAsB,EAAE,KAAK,CAAC;IACtF,wBAAwB,EACtB,yEAAyE;IAC3E,gBAAgB,EACd,mKAAmK;IACrK,YAAY,EAAE,aAAa;IAC3B,aAAa,EAAE,+BAA+B;IAC9C,KAAK,EAAE,+BAA+B;IACtC,IAAI,EAAE,gBAAgB;CACvB,CAAA;AAED,MAAM,CAAC,MAAM,gCAAgC,GAAG,SAAS;KACtD,KAAK,CAAC,WAAW,CAAC;KAClB,KAAK,CAAC,OAAO,CAAC;KACd,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC/B,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC;;CAEvB,CAAC;IACE,YAAY,EAAE,CAAC;SACZ,OAAO,EAAE;SACT,OAAO,CAAC,IAAI,CAAC;SACb,QAAQ,CAAC;;CAEf,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,eAAe,GAC1B,WAAW,CAAC,IAAI,EAAE,gCAAgC,CAAC,CAAA;AAErD,MAAM,CAAC,MAAM,EACX,gBAAgB,EAAE,gDAAgD,EAClE,cAAc,EAAE,8CAA8C,EAC9D,8BAA8B,EAAE,8DAA8D,GAC/F,GAAG,eAAe,CAAA"}