@transloadit/zod 4.5.0 → 5.0.0

package/dist/v3/robots/file-virusscan.js

@@ -1,53 +1,34 @@
 import { z } from 'zod/v3';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { createProcessingExample, defineRobotWithHiddenFields, robotBase, robotFileFilteringMeta, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    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',
-            },
-        },
-    },
+    ...robotFileFilteringMeta,
+    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.',
+    example_code: createProcessingExample('scanned', '/file/virusscan', {
+        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_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: 16,
     title: 'Scan files for viruses',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'FileVirusscanRobot',
-    priceFactor: 1,
     queueSlotCount: 16,
+    preserveInputFileUrls: true,
     minimumCharge: 1048576,
     lazyLoad: true,
     installVersionFile: typeof process !== 'undefined' && process.env.API2_CLAMD_INSTALL_VERSION_FILE
         ? process.env.API2_CLAMD_INSTALL_VERSION_FILE
         : '',
     isAllowedForUrlTransform: false,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotFileVirusscanInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: 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.
+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.
 
@@ -56,27 +37,20 @@ We allow the use of industry standard [EICAR files](https://www.eicar.org/downlo
     error_on_decline: 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.
-`),
+        .describe(robotParameterDocs.error_on_decline.description),
     error_msg: 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\`.
-`),
+        .describe(robotParameterDocs.error_msg.description),
 })
     .strict();
-export const robotFileVirusscanInstructionsWithHiddenFieldsSchema = robotFileVirusscanInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotFileVirusscanInstructionsSchema.shape.result])
-        .optional(),
+const hiddenFields = {
     can_use_daemon_fallback: z
         .boolean()
         .optional()
         .describe(`
 Allow the robot to use a daemon fallback mechanism if the primary scanning method fails.
 `),
-});
-export const interpolatableRobotFileVirusscanInstructionsSchema = interpolateRobot(robotFileVirusscanInstructionsSchema);
-export const interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema = interpolateRobot(robotFileVirusscanInstructionsWithHiddenFieldsSchema);
+};
+export const robotDefinition = defineRobotWithHiddenFields(meta, robotFileVirusscanInstructionsSchema, hiddenFields);
+export const { withHiddenFields: robotFileVirusscanInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotFileVirusscanInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotFileVirusscanInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v3/robots/file-watermark.d.ts

@@ -1,9 +1,11 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
+import { createRobotSchemaVariants } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotFileWatermarkInstructionsSchema: 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>;
@@ -61,11 +63,11 @@ export declare const robotFileWatermarkInstructionsSchema: z.ZodObject<{
     robot: z.ZodLiteral<"/file/watermark">;
     randomize: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/file/watermark";
     result: boolean;
+    robot: "/file/watermark";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -80,12 +82,13 @@ export declare const robotFileWatermarkInstructionsSchema: 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;
     randomize?: boolean | undefined;
 }, {
     robot: "/file/watermark";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -100,16 +103,19 @@ export declare const robotFileWatermarkInstructionsSchema: 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;
     randomize?: boolean | undefined;
 }>;
+declare const schemaVariants: ReturnType<typeof createRobotSchemaVariants<typeof robotFileWatermarkInstructionsSchema.shape>>;
 export declare const robotFileWatermarkInstructionsWithHiddenFieldsSchema: 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")[]>>;
@@ -167,9 +173,10 @@ export declare const robotFileWatermarkInstructionsWithHiddenFieldsSchema: z.Zod
     result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/watermark";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -184,13 +191,13 @@ export declare const robotFileWatermarkInstructionsWithHiddenFieldsSchema: z.Zod
         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;
     randomize?: boolean | undefined;
 }, {
     robot: "/file/watermark";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -205,18 +212,17 @@ export declare const robotFileWatermarkInstructionsWithHiddenFieldsSchema: z.Zod
         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;
     randomize?: boolean | undefined;
-}>;
-export type RobotFileWatermarkInstructions = z.infer<typeof robotFileWatermarkInstructionsSchema>;
-export type RobotFileWatermarkInstructionsWithHiddenFields = z.infer<typeof robotFileWatermarkInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotFileWatermarkInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotFileWatermarkInstructionsSchema: 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]>>;
@@ -272,11 +278,11 @@ export declare const interpolatableRobotFileWatermarkInstructionsSchema: z.ZodOb
     robot: z.ZodLiteral<"/file/watermark">;
     randomize: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }, "strict", z.ZodTypeAny, {
-    robot: "/file/watermark";
     result: string | boolean;
+    robot: "/file/watermark";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -291,12 +297,13 @@ export declare const interpolatableRobotFileWatermarkInstructionsSchema: z.ZodOb
         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;
     randomize?: string | boolean | undefined;
 }, {
     robot: "/file/watermark";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -311,18 +318,17 @@ export declare const interpolatableRobotFileWatermarkInstructionsSchema: z.ZodOb
         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;
     randomize?: string | boolean | undefined;
-}>;
-export type InterpolatableRobotFileWatermarkInstructions = InterpolatableRobotFileWatermarkInstructionsInput;
-export type InterpolatableRobotFileWatermarkInstructionsInput = z.input<typeof interpolatableRobotFileWatermarkInstructionsSchema>;
-export declare const interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema: 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")[]>]>>;
@@ -379,9 +385,10 @@ export declare const interpolatableRobotFileWatermarkInstructionsWithHiddenField
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, "strict", z.ZodTypeAny, {
     robot: "/file/watermark";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -396,13 +403,13 @@ export declare const interpolatableRobotFileWatermarkInstructionsWithHiddenField
         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;
     randomize?: string | boolean | undefined;
 }, {
     robot: "/file/watermark";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -417,13 +424,20 @@ export declare const interpolatableRobotFileWatermarkInstructionsWithHiddenField
         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;
     randomize?: string | boolean | undefined;
 }>;
-export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotFileWatermarkInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof schemaVariants>;
+export type RobotFileWatermarkInstructions = Instructions['output'];
+export type RobotFileWatermarkInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotFileWatermarkInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileWatermarkInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotFileWatermarkInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=file-watermark.d.ts.map

package/dist/v3/robots/file-watermark.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-watermark.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-watermark.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,cAkClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"file-watermark.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/file-watermark.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAE5F,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,EAEL,yBAAyB,EAI1B,MAAM,+BAA+B,CAAA;AAEtC,eAAO,MAAM,IAAI,EAAE,cAoBlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMtC,CAAA;AAEX,QAAA,MAAM,cAAc,EAAE,UAAU,CAC9B,OAAO,yBAAyB,CAAC,OAAO,oCAAoC,CAAC,KAAK,CAAC,CAClB,CAAA;AACnE,eAAO,MACa,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACtD,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEhE,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACpD,CAAA;AAElB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,cAAc,CAAC,CAAA;AAElE,MAAM,MAAM,8BAA8B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACnE,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,iDAAiD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACnG,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,iEAAiE,GAC3E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

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

package/dist/v3/robots/ftp-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 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">>]>>;
+    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>;
@@ -23,42 +24,46 @@ export declare const robotFtpImportInstructionsSchema: z.ZodObject<{
     passive_mode: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/ftp/import";
     result: boolean;
+    robot: "/ftp/import";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
     port: number;
     passive_mode: boolean;
+    user?: string | 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;
 }, {
     path: string | string[];
     robot: "/ftp/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
+    user?: string | 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;
-    user?: string | undefined;
     host?: string | undefined;
     port?: number | undefined;
     password?: 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">>]>>;
+    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">]>>>;
@@ -77,43 +82,43 @@ export declare const robotFtpImportInstructionsWithHiddenFieldsSchema: z.ZodObje
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/ftp/import";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
     port: number;
     passive_mode: boolean;
+    result?: boolean | "debug" | undefined;
+    user?: string | 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;
 }, {
     path: string | string[];
     robot: "/ftp/import";
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
+    user?: string | 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;
-    user?: string | undefined;
     host?: string | undefined;
     port?: number | undefined;
     password?: 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<{
-    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">>]>>;
+}>, interpolatableRobotFtpImportInstructionsSchema: 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]>>;
@@ -130,44 +135,44 @@ export declare const interpolatableRobotFtpImportInstructionsSchema: z.ZodObject
     passive_mode: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/ftp/import";
     result: string | boolean;
+    robot: "/ftp/import";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
     port: string | number;
     passive_mode: string | boolean;
+    user?: 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;
     host?: string | undefined;
     password?: string | undefined;
 }, {
     path: string | string[];
     robot: "/ftp/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;
+    user?: string | 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;
-    user?: string | undefined;
     host?: string | undefined;
     port?: string | number | undefined;
     password?: string | undefined;
     passive_mode?: string | boolean | undefined;
-}>;
-export type InterpolatableRobotFtpImportInstructions = InterpolatableRobotFtpImportInstructionsInput;
-export type InterpolatableRobotFtpImportInstructionsInput = z.input<typeof interpolatableRobotFtpImportInstructionsSchema>;
-export declare const 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">>]>>;
+}>, interpolatableRobotFtpImportInstructionsWithHiddenFieldsSchema: 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">]>]>>>;
@@ -185,38 +190,46 @@ export declare const interpolatableRobotFtpImportInstructionsWithHiddenFieldsSch
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/ftp/import";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
     port: string | number;
     passive_mode: string | boolean;
+    result?: string | boolean | undefined;
+    user?: 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;
     host?: string | undefined;
     password?: string | undefined;
 }, {
     path: string | string[];
     robot: "/ftp/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;
+    user?: string | 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;
-    user?: string | undefined;
     host?: string | undefined;
     port?: string | number | undefined;
     password?: 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/v3/robots/ftp-import.d.ts.map

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