transloadit 3.0.2 → 4.0.0-4

package/dist/alphalib/types/robots/file-virusscan.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotFileVirusscanInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+}>, {
+    robot: z.ZodLiteral<"/file/virusscan">;
+    error_on_decline: z.ZodDefault<z.ZodBoolean>;
+    error_msg: z.ZodDefault<z.ZodString>;
+}>, "strict", z.ZodTypeAny, {
+    robot: "/file/virusscan";
+    result: boolean;
+    error_on_decline: boolean;
+    error_msg: string;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+}, {
+    robot: "/file/virusscan";
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    error_on_decline?: boolean | undefined;
+    error_msg?: string | undefined;
+}>;
+export type RobotFileVirusscanInstructions = z.infer<typeof robotFileVirusscanInstructionsSchema>;
+//# sourceMappingURL=file-virusscan.d.ts.map

package/dist/alphalib/types/robots/file-virusscan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-virusscan.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-virusscan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SAiClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBtC,CAAA;AAEX,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA"}

package/dist/alphalib/types/robots/file-virusscan.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotFileVirusscanInstructionsSchema = exports.meta = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.meta = {
+    allowed_for_url_transform: false,
+    bytescount: 1,
+    description: 'While 100% security is a myth, having /file/virusscan as a gatekeeper bot helps reject millions of trojans, viruses, malware & other malicious threats before they reach your platform.',
+    discount_factor: 1,
+    discount_pct: 0,
+    example_code: {
+        steps: {
+            scanned: {
+                robot: '/file/virusscan',
+                use: ':original',
+                error_on_decline: true,
+                error_msg: 'At least one of the uploaded files is malicious and was declined',
+            },
+        },
+    },
+    example_code_description: 'Scan uploaded files and throw an error if a malicious file is detected:',
+    minimum_charge: 1048576,
+    ogimage: '/assets/images/robots/ogimages/file-virusscan.jpg',
+    output_factor: 1,
+    override_lvl1: 'File Filtering',
+    purpose_sentence: 'rejects millions of trojans, viruses, malware & other malicious threats before they reach your platform',
+    purpose_verb: 'scan',
+    purpose_word: 'scan for viruses and reject malware',
+    purpose_words: 'Scan files for viruses',
+    service_slug: 'file-filtering',
+    slot_count: 38,
+    title: 'Scan files for viruses',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotFileVirusscanInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .extend({
+    robot: zod_1.z.literal('/file/virusscan').describe(`
+      This <dfn>Robot</dfn> is built on top of [ClamAV](https://www.clamav.net/), the best open source antivirus engine available. We update its signatures on a daily basis.
+
+By default, this <dfn>Robot</dfn> excludes all malicious files from further processing without any additional notification. This behavior can be changed by setting \`error_on_decline\` to \`true\`, which will stop <dfn>Assemblies</dfn> as soon as malicious files are found. Such <dfn>Assemblies</dfn> will then be marked with an error.
+
+We allow the use of industry standard [EICAR files](https://www.eicar.org/download-anti-malware-testfile/) for integration testing without needing to use potentially dangerous live virus samples.
+`),
+    error_on_decline: zod_1.z.boolean().default(false).describe(`
+If this is set to \`true\` and one or more files are declined, the Assembly will be stopped and marked with an error.
+`),
+    error_msg: zod_1.z.string().default('One of your files was declined').describe(`
+The error message shown to your users (such as by Uppy) when a file is declined and \`error_on_decline\` is set to \`true\`.
+`),
+})
+    .strict();
+//# sourceMappingURL=file-virusscan.js.map

package/dist/alphalib/types/robots/file-virusscan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-virusscan.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-virusscan.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAmE;AAGtD,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,KAAK;IAChC,UAAU,EAAE,CAAC;IACb,WAAW,EACT,6LAA6L;IAC/L,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,OAAO,EAAE;gBACP,KAAK,EAAE,iBAAiB;gBACxB,GAAG,EAAE,WAAW;gBAChB,gBAAgB,EAAE,IAAI;gBACtB,SAAS,EAAE,kEAAkE;aAC9E;SACF;KACF;IACD,wBAAwB,EACtB,yEAAyE;IAC3E,cAAc,EAAE,OAAO;IACvB,OAAO,EAAE,mDAAmD;IAC5D,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EACd,6GAA6G;IAC/G,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,qCAAqC;IACnD,aAAa,EAAE,wBAAwB;IACvC,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,wBAAwB;IAC/B,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,oCAAoC,GAAG,uCAAS;KAC1D,KAAK,CAAC,sCAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC;;;;;;CAMhD,CAAC;IACE,gBAAgB,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;CAEzD,CAAC;IACE,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC,QAAQ,CAAC;;CAE5E,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/file-watermark.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+export declare const robotFileWatermarkInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+}>, {
+    robot: z.ZodLiteral<"/file/watermark">;
+    randomize: z.ZodOptional<z.ZodBoolean>;
+}>, "strict", z.ZodTypeAny, {
+    robot: "/file/watermark";
+    result: boolean;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    randomize?: boolean | undefined;
+}, {
+    robot: "/file/watermark";
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    randomize?: boolean | undefined;
+}>;
+export type RobotFileWatermarkInstructions = z.infer<typeof robotFileWatermarkInstructionsSchema>;
+//# sourceMappingURL=file-watermark.d.ts.map

package/dist/alphalib/types/robots/file-watermark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-watermark.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-watermark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMtC,CAAA;AAEX,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA"}

package/dist/alphalib/types/robots/file-watermark.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotFileWatermarkInstructionsSchema = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.robotFileWatermarkInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .extend({
+    robot: zod_1.z.literal('/file/watermark'),
+    randomize: zod_1.z.boolean().optional(),
+})
+    .strict();
+//# sourceMappingURL=file-watermark.js.map

package/dist/alphalib/types/robots/file-watermark.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-watermark.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-watermark.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAmE;AAEtD,QAAA,oCAAoC,GAAG,uCAAS;KAC1D,KAAK,CAAC,sCAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC;IACnC,SAAS,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/ftp-import.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotFtpImportInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import"]>, "many">]>, string[], boolean | ("meta" | "import")[]>>;
+}>, {
+    credentials: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+}>, {
+    robot: z.ZodLiteral<"/ftp/import">;
+    path: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    passive_mode: z.ZodDefault<z.ZodBoolean>;
+}>, "strict", z.ZodTypeAny, {
+    path: string | string[];
+    port: number;
+    robot: "/ftp/import";
+    result: boolean;
+    ignore_errors: string[];
+    passive_mode: boolean;
+    host?: string | undefined;
+    password?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+}, {
+    path: string | string[];
+    robot: "/ftp/import";
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    ignore_errors?: boolean | ("meta" | "import")[] | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    passive_mode?: boolean | undefined;
+}>;
+export type RobotFtpImportInstructions = z.infer<typeof robotFtpImportInstructionsSchema>;
+export type RobotFtpImportInstructionsInput = z.input<typeof robotFtpImportInstructionsSchema>;
+//# sourceMappingURL=ftp-import.d.ts.map

package/dist/alphalib/types/robots/ftp-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftp-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/ftp-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SA6BlB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYlC,CAAA;AAEX,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACzF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA"}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotFtpImportInstructionsSchema = exports.meta = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.meta = {
+    allowed_for_url_transform: true,
+    bytescount: 10,
+    discount_factor: 0.1,
+    discount_pct: 90,
+    example_code: {
+        steps: {
+            imported: {
+                robot: '/ftp/import',
+                credentials: 'YOUR_FTP_CREDENTIALS',
+                path: 'path/to/files/',
+            },
+        },
+    },
+    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',
+};
+exports.robotFtpImportInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotImport)
+    .merge(_instructions_primitives_ts_1.ftpBase)
+    .extend({
+    robot: zod_1.z.literal('/ftp/import'),
+    path: _instructions_primitives_ts_1.path.describe(`
+The path on your FTP server where to search for files. Files are imported recursively from all sub-directories and sub-sub-directories (and so on) from this path.
+`),
+    passive_mode: zod_1.z.boolean().default(true).describe(`
+Determines if passive mode should be used for the FTP connection.
+`),
+})
+    .strict();
+//# sourceMappingURL=ftp-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ftp-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/ftp-import.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAqF;AAGxE,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,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;CAC1B,CAAA;AAEY,QAAA,gCAAgC,GAAG,uCAAS;KACtD,KAAK,CAAC,yCAAW,CAAC;KAClB,KAAK,CAAC,qCAAO,CAAC;KACd,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC/B,IAAI,EAAE,kCAAI,CAAC,QAAQ,CAAC;;CAEvB,CAAC;IACE,YAAY,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC;;CAEpD,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/ftp-store.d.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotFtpStoreInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+}>, {
+    credentials: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodDefault<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.ZodBoolean>;
+}>, "strict", z.ZodTypeAny, {
+    path: string;
+    port: number;
+    robot: "/ftp/store";
+    result: boolean;
+    url_template: string;
+    ssl_url_template: string;
+    secure: boolean;
+    host?: string | undefined;
+    password?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+}, {
+    robot: "/ftp/store";
+    path?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    url_template?: string | undefined;
+    ssl_url_template?: string | undefined;
+    secure?: boolean | undefined;
+}>;
+export type RobotFtpStoreInstructions = z.infer<typeof robotFtpStoreInstructionsSchema>;
+export type RobotFtpStoreInstructionsInput = z.input<typeof robotFtpStoreInstructionsSchema>;
+//# sourceMappingURL=ftp-store.d.ts.map

package/dist/alphalib/types/robots/ftp-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftp-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/ftp-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SA8BlB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBjC,CAAA;AAEX,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA"}

package/dist/alphalib/types/robots/ftp-store.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotFtpStoreInstructionsSchema = exports.meta = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.meta = {
+    allowed_for_url_transform: true,
+    bytescount: 6,
+    discount_factor: 0.15000150001500018,
+    discount_pct: 84.99984999849998,
+    docs_redirect_from: ['/docs/export-to-your-own-ftp-server/'],
+    example_code: {
+        steps: {
+            exported: {
+                robot: '/ftp/store',
+                use: ':original',
+                credentials: 'YOUR_FTP_CREDENTIALS',
+                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+            },
+        },
+    },
+    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',
+};
+exports.robotFtpStoreInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .merge(_instructions_primitives_ts_1.ftpBase)
+    .extend({
+    robot: zod_1.z.literal('/ftp/store'),
+    path: zod_1.z.string().default('${unique_prefix}/${file.url_name}').describe(`
+The path at which the file is to be stored. This can contain any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables).
+
+Please note that you might need to include your homedir at the beginning of the path.
+`),
+    url_template: zod_1.z.string().default('https://{HOST}/{PATH}').describe(`
+The URL of the file in the result JSON. The following [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables) are supported.
+`),
+    ssl_url_template: zod_1.z.string().default('https://{HOST}/{PATH}').describe(`
+The SSL URL of the file in the result JSON. The following [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables) are supported.
+`),
+    secure: zod_1.z.boolean().default(false).describe(`
+Determines whether to establish a secure connection to the FTP server using SSL.
+`),
+})
+    .strict();
+//# sourceMappingURL=ftp-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ftp-store.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/ftp-store.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAA4E;AAG/D,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,mBAAmB;IACpC,YAAY,EAAE,iBAAiB;IAC/B,kBAAkB,EAAE,CAAC,sCAAsC,CAAC;IAC5D,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,YAAY;gBACnB,GAAG,EAAE,WAAW;gBAChB,WAAW,EAAE,sBAAsB;gBACnC,IAAI,EAAE,oDAAoD;aAC3D;SACF;KACF;IACD,wBAAwB,EAAE,+DAA+D;IACzF,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EACd,uIAAuI;IACzI,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,aAAa;IAC3B,aAAa,EAAE,6BAA6B;IAC5C,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,6BAA6B;IACpC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,+BAA+B,GAAG,uCAAS;KACrD,KAAK,CAAC,sCAAQ,CAAC;KACf,KAAK,CAAC,qCAAO,CAAC;KACd,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,YAAY,CAAC;IAC9B,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,QAAQ,CAAC;;;;CAI1E,CAAC;IACE,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC;;CAEtE,CAAC;IACE,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC;;CAE1E,CAAC;IACE,MAAM,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;CAE/C,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/google-import.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotGoogleImportInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import"]>, "many">]>, string[], boolean | ("meta" | "import")[]>>;
+}>, {
+    credentials: z.ZodOptional<z.ZodString>;
+}>, {
+    robot: z.ZodLiteral<"/google/import">;
+    path: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    next_page_token: z.ZodDefault<z.ZodString>;
+    files_per_page: z.ZodDefault<z.ZodNumber>;
+}>, "strict", z.ZodTypeAny, {
+    path: string | string[];
+    recursive: boolean;
+    robot: "/google/import";
+    result: boolean;
+    ignore_errors: string[];
+    next_page_token: string;
+    files_per_page: number;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    credentials?: string | undefined;
+}, {
+    path: string | string[];
+    robot: "/google/import";
+    recursive?: boolean | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    ignore_errors?: boolean | ("meta" | "import")[] | undefined;
+    credentials?: string | undefined;
+    next_page_token?: string | undefined;
+    files_per_page?: number | undefined;
+}>;
+export type RobotGoogleImportInstructions = z.infer<typeof robotGoogleImportInstructionsSchema>;
+export type RobotGoogleImportInstructionsInput = z.input<typeof robotGoogleImportInstructionsSchema>;
+//# sourceMappingURL=google-import.d.ts.map

package/dist/alphalib/types/robots/google-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SA8BlB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BrC,CAAA;AAEX,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA"}