@transloadit/node 4.1.3

package/dist/alphalib/types/robots/script-run.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+export const meta = {
+    allowed_for_url_transform: true,
+    bytescount: 10,
+    discount_factor: 0.1,
+    discount_pct: 90,
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'Code Evaluation',
+    purpose_sentence: 'runs scripts in Assemblies',
+    purpose_verb: 'run',
+    purpose_word: 'script',
+    purpose_words: 'Run scripts in Assemblies',
+    service_slug: 'code-evaluation',
+    slot_count: 5,
+    title: 'Run Scripts',
+    typical_file_size_mb: 0.0001,
+    typical_file_type: 'file',
+    name: 'ScriptRunRobot',
+    priceFactor: 10,
+    queueSlotCount: 5,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: false,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+export const robotScriptRunInstructionsSchema = robotBase
+    .merge(robotUse)
+    .extend({
+    robot: z.literal('/script/run').describe(`
+This <dfn>Robot</dfn> allows you to run arbitrary \`JavaScript\` as part of the <dfn>Assembly</dfn>
+execution process. The <dfn>Robot</dfn> is invoked automatically when there are <dfn>Assembly
+Instructions</dfn> containing \`\${...}\`:
+
+\`\`\`json
+{
+  "robot": "/image/resize",
+  "width": "\${Math.max(file.meta.width, file.meta.height)}"
+}
+\`\`\`
+
+You can also invoke this <dfn>Robot</dfn> directly, leaving out the \`\${...}\`:
+
+\`\`\`json
+{
+  "robot": "/script/run",
+  "script": "Math.max(file.meta.width, file.meta.height)"
+}
+\`\`\`
+
+When accessing arrays, the syntax is the same as in any JavaScript program:
+
+\`\`\`json
+{
+  "robot": "/image/resize",
+  "width": "\${file.meta.faces[0].width * 2}"
+}
+\`\`\`
+
+Compared to only accessing an <dfn>Assembly Variable</dfn>:
+
+\`\`\`json
+{
+  "robot": "/image/resize",
+  "width": "\${file.meta.faces[0].width}"
+}
+\`\`\`
+
+For more information, see [Dynamic Evaluation](/docs/topics/dynamic-evaluation/).
+`),
+    script: z.string().describe(`
+A string of JavaScript to evaluate. It has access to all JavaScript features available in a modern browser environment.
+
+The script is expected to return a \`JSON.stringify\`-able value in the same tick, so no \`await\` or callbacks are allowed (yet).
+
+If the script does not finish within 1000ms it times out with an error. The return value or error is exported as \`file.meta.result\`. If there was an error, \`file.meta.isError\` is \`true\`. Note that the <dfn>Assembly</dfn> will not crash in this case. If you need it to crash, you can check this value with a [🤖/file/filter](/docs/robots/file-filter/) <dfn>Step</dfn>, setting \`error_on_decline\` to \`true\`.
+
+You can check whether evaluating this script was free by inspecting \`file.meta.isFree\`. It is recommended to do this during development as to not see sudden unexpected costs in production.
+`),
+})
+    .strict();
+export const robotScriptRunInstructionsWithHiddenFieldsSchema = robotScriptRunInstructionsSchema.extend({
+    result: z.union([z.literal('debug'), robotScriptRunInstructionsSchema.shape.result]).optional(),
+    contextJSON: z
+        .string()
+        .optional()
+        .describe(`
+A JSON string that provides additional context data to the script. This will be parsed and made available to the script as a \`context\` variable. For example, if you pass \`'{"foo":{"bar":"baz"}}'\`, the script can access \`context.foo.bar\` to get the value \`"baz"\`.
+`),
+});
+export const interpolatableRobotScriptRunInstructionsSchema = interpolateRobot(robotScriptRunInstructionsSchema);
+export const interpolatableRobotScriptRunInstructionsWithHiddenFieldsSchema = interpolateRobot(robotScriptRunInstructionsWithHiddenFieldsSchema);
+//# sourceMappingURL=script-run.js.map

package/dist/alphalib/types/robots/script-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-run.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/script-run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAErF,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,EAAE;IACd,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,EAAE;IAChB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,iBAAiB;IAChC,gBAAgB,EAAE,4BAA4B;IAC9C,YAAY,EAAE,KAAK;IACnB,YAAY,EAAE,QAAQ;IACtB,aAAa,EAAE,2BAA2B;IAC1C,YAAY,EAAE,iBAAiB;IAC/B,UAAU,EAAE,CAAC;IACb,KAAK,EAAE,aAAa;IACpB,oBAAoB,EAAE,MAAM;IAC5B,iBAAiB,EAAE,MAAM;IACzB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EAAE,EAAE;IACf,cAAc,EAAE,CAAC;IACjB,wBAAwB,EAAE,IAAI;IAC9B,mBAAmB,EAAE,KAAK;IAC1B,UAAU,EAAE,KAAK;IACjB,iDAAiD,EAAE,KAAK;IACxD,KAAK,EAAE,IAAI;CACZ,CAAA;AAED,MAAM,CAAC,MAAM,gCAAgC,GAAG,SAAS;KACtD,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwC5C,CAAC;IACE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC;;;;;;;;CAQ/B,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;IAC/F,WAAW,EAAE,CAAC;SACX,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC;;CAEf,CAAC;CACC,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,8CAA8C,GAAG,gBAAgB,CAC5E,gCAAgC,CACjC,CAAA;AAOD,MAAM,CAAC,MAAM,8DAA8D,GAAG,gBAAgB,CAC5F,gDAAgD,CACjD,CAAA"}

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

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotSftpImportInstructionsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    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")[]>>;
+} & {
+    credentials: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    public_key: z.ZodOptional<z.ZodString>;
+} & {
+    robot: z.ZodLiteral<"/sftp/import">;
+    path: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    port: number;
+    result: boolean;
+    robot: "/sftp/import";
+    force_accept: boolean;
+    ignore_errors: string[];
+    force_name: string | string[] | null;
+    host?: string | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+}, {
+    path: string;
+    robot: "/sftp/import";
+    host?: string | undefined;
+    port?: number | undefined;
+    result?: boolean | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+    force_accept?: boolean | undefined;
+    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | string[] | null | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+}>;
+export declare const robotSftpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    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")[]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    public_key: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/sftp/import">;
+    path: z.ZodString;
+} & {
+    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+    allowNetwork: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    port: number;
+    robot: "/sftp/import";
+    force_accept: boolean;
+    ignore_errors: string[];
+    force_name: string | string[] | null;
+    host?: string | undefined;
+    result?: boolean | "debug" | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+    allowNetwork?: string | undefined;
+}, {
+    path: string;
+    robot: "/sftp/import";
+    host?: string | undefined;
+    port?: number | undefined;
+    result?: boolean | "debug" | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+    force_accept?: boolean | undefined;
+    ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | string[] | null | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+    allowNetwork?: string | undefined;
+}>;
+export type RobotSftpImportInstructions = z.infer<typeof robotSftpImportInstructionsSchema>;
+export type RobotSftpImportInstructionsWithHiddenFields = z.infer<typeof robotSftpImportInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotSftpImportInstructionsSchema: z.ZodObject<{
+    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">]>]>>;
+    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")[]>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    user: z.ZodOptional<z.ZodString>;
+    public_key: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/sftp/import">;
+    path: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    port: string | number;
+    result: string | boolean;
+    robot: "/sftp/import";
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    force_name: string | string[] | null;
+    host?: string | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+}, {
+    path: string;
+    robot: "/sftp/import";
+    host?: string | undefined;
+    port?: string | number | undefined;
+    result?: string | boolean | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | string[] | null | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+}>;
+export type InterpolatableRobotSftpImportInstructions = InterpolatableRobotSftpImportInstructionsInput;
+export type InterpolatableRobotSftpImportInstructionsInput = z.input<typeof interpolatableRobotSftpImportInstructionsSchema>;
+export declare const interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    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">]>]>>;
+    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")[]>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    user: z.ZodOptional<z.ZodString>;
+    public_key: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/sftp/import">;
+    path: z.ZodString;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    allowNetwork: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    port: string | number;
+    robot: "/sftp/import";
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    force_name: string | string[] | null;
+    host?: string | undefined;
+    result?: string | boolean | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+    allowNetwork?: string | undefined;
+}, {
+    path: string;
+    robot: "/sftp/import";
+    host?: string | undefined;
+    port?: string | number | undefined;
+    result?: string | boolean | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    force_accept?: string | boolean | undefined;
+    ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
+    force_name?: string | string[] | null | undefined;
+    credentials?: string | undefined;
+    user?: string | undefined;
+    public_key?: string | undefined;
+    allowNetwork?: string | undefined;
+}>;
+export type InterpolatableRobotSftpImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotSftpImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=sftp-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sftp-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/sftp-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { interpolateRobot, robotBase, robotImport, sftpBase } from "./_instructions-primitives.js";
+export const meta = {
+    allowed_for_url_transform: true,
+    bytescount: 10,
+    discount_factor: 0.1,
+    discount_pct: 90,
+    example_code: {
+        steps: {
+            imported: {
+                robot: '/sftp/import',
+                credentials: 'YOUR_SFTP_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 SFTP servers into Transloadit. This Robot relies on public key authentication',
+    purpose_verb: 'import',
+    purpose_word: 'SFTP servers',
+    purpose_words: 'Import files from SFTP servers',
+    service_slug: 'file-importing',
+    slot_count: 20,
+    title: 'Import files from SFTP servers',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+    name: 'SftpImportRobot',
+    priceFactor: 6.6666,
+    queueSlotCount: 20,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: false,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+    stage: 'ga',
+};
+export const robotSftpImportInstructionsSchema = robotBase
+    .merge(robotImport)
+    .merge(sftpBase)
+    .extend({
+    robot: z.literal('/sftp/import'),
+    path: z.string().describe(`
+The path on your SFTP server where to search for files.
+`),
+})
+    .strict();
+export const robotSftpImportInstructionsWithHiddenFieldsSchema = robotSftpImportInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotSftpImportInstructionsSchema.shape.result])
+        .optional(),
+    allowNetwork: z
+        .string()
+        .optional()
+        .describe(`
+Network access permission for the SFTP connection. This is used to control which networks the SFTP robot can access.
+`),
+});
+export const interpolatableRobotSftpImportInstructionsSchema = interpolateRobot(robotSftpImportInstructionsSchema);
+export const interpolatableRobotSftpImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotSftpImportInstructionsWithHiddenFieldsSchema);
+//# sourceMappingURL=sftp-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sftp-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/sftp-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAElG,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,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,cAAc;gBACrB,WAAW,EAAE,uBAAuB;gBACpC,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,0HAA0H;IAC5H,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,cAAc;IAC5B,aAAa,EAAE,gCAAgC;IAC/C,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,gCAAgC;IACvC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;IACzB,IAAI,EAAE,iBAAiB;IACvB,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,iCAAiC,GAAG,SAAS;KACvD,KAAK,CAAC,WAAW,CAAC;KAClB,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;IAChC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC;;CAE7B,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,iDAAiD,GAC5D,iCAAiC,CAAC,MAAM,CAAC;IACvC,MAAM,EAAE,CAAC;SACN,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,iCAAiC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC3E,QAAQ,EAAE;IACb,YAAY,EAAE,CAAC;SACZ,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC;;CAEf,CAAC;CACC,CAAC,CAAA;AAOJ,MAAM,CAAC,MAAM,+CAA+C,GAAG,gBAAgB,CAC7E,iCAAiC,CAClC,CAAA;AAQD,MAAM,CAAC,MAAM,+DAA+D,GAAG,gBAAgB,CAC7F,iDAAiD,CAClD,CAAA"}