@transloadit/zod 4.5.0 → 5.0.1

package/dist/v3/robots/s3-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 robotS3ImportInstructionsSchema: 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>;
@@ -27,13 +28,14 @@ export declare const robotS3ImportInstructionsSchema: z.ZodObject<{
     range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/s3/import";
     result: boolean;
+    robot: "/s3/import";
+    recursive: boolean;
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     return_file_stubs: boolean;
     key?: string | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
@@ -50,9 +52,11 @@ export declare const robotS3ImportInstructionsSchema: z.ZodObject<{
     path: string | string[];
     robot: "/s3/import";
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | undefined;
+    recursive?: boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -62,15 +66,16 @@ export declare const robotS3ImportInstructionsSchema: z.ZodObject<{
     bucket?: string | undefined;
     secret?: string | undefined;
     bucket_region?: string | undefined;
-    recursive?: boolean | undefined;
     files_per_page?: number | undefined;
     page_number?: number | undefined;
     return_file_stubs?: boolean | undefined;
     range?: string | string[] | undefined;
 }>;
+export declare const robotDefinition: RobotDefinition<typeof robotS3ImportInstructionsSchema.shape>;
 export declare const robotS3ImportInstructionsWithHiddenFieldsSchema: 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">]>>>;
@@ -93,16 +98,17 @@ export declare const robotS3ImportInstructionsWithHiddenFieldsSchema: z.ZodObjec
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/s3/import";
+    recursive: boolean;
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     force_name: string | string[] | null;
     import_on_errors: "meta"[];
-    recursive: boolean;
     return_file_stubs: boolean;
     key?: string | undefined;
+    result?: boolean | "debug" | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
     bucket?: string | undefined;
@@ -115,9 +121,11 @@ export declare const robotS3ImportInstructionsWithHiddenFieldsSchema: z.ZodObjec
     path: string | string[];
     robot: "/s3/import";
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
+    recursive?: boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -127,17 +135,14 @@ export declare const robotS3ImportInstructionsWithHiddenFieldsSchema: z.ZodObjec
     bucket?: string | undefined;
     secret?: string | undefined;
     bucket_region?: string | undefined;
-    recursive?: boolean | undefined;
     files_per_page?: number | undefined;
     page_number?: number | undefined;
     return_file_stubs?: boolean | undefined;
     range?: string | string[] | undefined;
-}>;
-export type RobotS3ImportInstructions = z.infer<typeof robotS3ImportInstructionsSchema>;
-export type RobotS3ImportInstructionsWithHiddenFields = z.infer<typeof robotS3ImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotS3ImportInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotS3ImportInstructionsSchema: 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]>>;
@@ -158,13 +163,14 @@ export declare const interpolatableRobotS3ImportInstructionsSchema: z.ZodObject<
     range: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
-    robot: "/s3/import";
     result: string | boolean;
+    robot: "/s3/import";
+    recursive: string | boolean;
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     return_file_stubs: string | boolean;
     key?: string | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
@@ -181,9 +187,11 @@ export declare const interpolatableRobotS3ImportInstructionsSchema: z.ZodObject<
     path: string | string[];
     robot: "/s3/import";
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    recursive?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -193,17 +201,14 @@ export declare const interpolatableRobotS3ImportInstructionsSchema: z.ZodObject<
     bucket?: string | undefined;
     secret?: string | undefined;
     bucket_region?: string | undefined;
-    recursive?: string | boolean | undefined;
     files_per_page?: string | number | undefined;
     page_number?: string | number | undefined;
     return_file_stubs?: string | boolean | undefined;
     range?: string | string[] | undefined;
-}>;
-export type InterpolatableRobotS3ImportInstructions = InterpolatableRobotS3ImportInstructionsInput;
-export type InterpolatableRobotS3ImportInstructionsInput = z.input<typeof interpolatableRobotS3ImportInstructionsSchema>;
-export declare const interpolatableRobotS3ImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotS3ImportInstructionsWithHiddenFieldsSchema: 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">]>]>>>;
@@ -225,16 +230,17 @@ export declare const interpolatableRobotS3ImportInstructionsWithHiddenFieldsSche
 }, "strict", z.ZodTypeAny, {
     path: string | string[];
     robot: "/s3/import";
+    recursive: string | boolean;
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     force_name: string | string[] | null;
     import_on_errors: string | string[];
-    recursive: string | boolean;
     return_file_stubs: string | boolean;
     key?: string | undefined;
+    result?: string | boolean | undefined;
     interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
     bucket?: string | undefined;
@@ -247,9 +253,11 @@ export declare const interpolatableRobotS3ImportInstructionsWithHiddenFieldsSche
     path: string | string[];
     robot: "/s3/import";
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
-    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
+    recursive?: string | boolean | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("import" | "meta" | "execute")[] | undefined;
@@ -259,12 +267,17 @@ export declare const interpolatableRobotS3ImportInstructionsWithHiddenFieldsSche
     bucket?: string | undefined;
     secret?: string | undefined;
     bucket_region?: string | undefined;
-    recursive?: string | boolean | undefined;
     files_per_page?: string | number | undefined;
     page_number?: string | number | undefined;
     return_file_stubs?: string | boolean | undefined;
     range?: string | string[] | undefined;
 }>;
-export type InterpolatableRobotS3ImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotS3ImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotS3ImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotS3ImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotS3ImportInstructions = Instructions['output'];
+export type RobotS3ImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotS3ImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotS3ImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotS3ImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotS3ImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=s3-import.d.ts.map

package/dist/v3/robots/s3-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"s3-import.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/s3-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAc1B,eAAO,MAAM,IAAI,EAAE,cAsClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyFjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}
+{"version":3,"file":"s3-import.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/s3-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;AAgB1B,eAAO,MAAM,IAAI,EAAE,cAclB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFjC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,+BAA+B,CAAC,KAAK,CACtC,CAAA;AAEpD,eAAO,MACa,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACjD,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC7B,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC5E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,yBAAyB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAC9D,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACpF,MAAM,MAAM,uCAAuC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACzF,MAAM,MAAM,4CAA4C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC9F,MAAM,MAAM,uDAAuD,GACjE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,4DAA4D,GACtE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,42 +1,18 @@
 import { z } from 'zod/v3';
-import { files_per_page, interpolateRobot, page_number, path, recursive, return_file_stubs, robotBase, robotImport, s3Base, } from "./_instructions-primitives.js";
+import { createStorageImportExample, defineRobot, files_per_page, page_number, path, recursiveImport, return_file_stubs, robotBase, robotImport, robotImportMeta, s3Base, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
-    example_code: {
-        steps: {
-            imported: {
-                robot: '/s3/import',
-                credentials: 'YOUR_AWS_CREDENTIALS',
-                path: 'path/to/files/',
-                recursive: true,
-            },
-        },
-    },
+    ...robotImportMeta,
+    example_code: createStorageImportExample('/s3/import', 'YOUR_AWS_CREDENTIALS'),
     example_code_description: 'Import files from the `path/to/files` directory and its subdirectories:',
     has_small_icon: true,
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Importing',
     purpose_sentence: 'imports whole directories of files from your S3 bucket',
-    purpose_verb: 'import',
     purpose_word: 'Amazon S3',
     purpose_words: 'Import files from Amazon S3',
     requires_credentials: true,
-    service_slug: 'file-importing',
-    slot_count: 10,
     title: 'Import files from Amazon S3',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'S3ImportRobot',
     priceFactor: 10,
     queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-    stage: 'ga',
 };
 export const robotS3ImportInstructionsSchema = robotBase
     .merge(robotImport)
@@ -54,7 +30,7 @@ The URL to the result file in your S3 bucket will be returned in the <dfn>Assemb
 
 ## Limit access
 
-You will also need to add permissions to your bucket so that Transloadit can access it properly. Here is an example IAM policy that you can use. Following the [principle of least privilege](https://en.wikipedia.org/wiki/Principle_of_least_privilege), it contains the **minimum required permissions** to export a file to your S3 bucket using Transloadit. You may require more permissions (especially viewing permissions) depending on your application.
+You will also need to add permissions to your bucket so that Transloadit can access it properly. Here is an example IAM policy that you can use. Following the [principle of least privilege](https://en.wikipedia.org/wiki/Principle_of_least_privilege), it contains the **minimum required permissions** to import a file from your S3 bucket using Transloadit. You may require more permissions (especially viewing permissions) depending on your application.
 
 Please change \`{BUCKET_NAME}\` in the values for \`Sid\` and \`Resource\` accordingly. Also, this policy will grant the minimum required permissions to all your users. We advise you to create a separate Amazon IAM user, and use its User ARN (can be found in the "Summary" tab of a user [here](https://console.aws.amazon.com/iam/home#users)) for the \`Principal\` value. More information about this can be found [here](https://docs.aws.amazon.com/AmazonS3/latest/dev/AccessPolicyLanguage_UseCases_s3_a.html).
 
@@ -91,11 +67,7 @@ If you want to import all files from the root directory, please use \`/\` as the
 
 You can also use an array of path strings here to import multiple paths in the same <dfn>Robot</dfn>'s <dfn>Step</dfn>.
 `),
-    recursive: recursive.describe(`
-Setting this to \`true\` will enable importing files from subdirectories and sub-subdirectories (etc.) of the given path.
-
-Please use the pagination parameters \`page_number\` and \`files_per_page\` wisely here.
-`),
+    recursive: recursiveImport,
     page_number: page_number.optional().describe(`
 The pagination page number. For now, in order to not break backwards compatibility in non-recursive imports, this only works when recursive is set to \`true\`.
 
@@ -128,8 +100,5 @@ Allows you to specify one or more byte ranges to import from the file. S3 must s
 `),
 })
     .strict();
-export const robotS3ImportInstructionsWithHiddenFieldsSchema = robotS3ImportInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotS3ImportInstructionsSchema.shape.result]).optional(),
-});
-export const interpolatableRobotS3ImportInstructionsSchema = interpolateRobot(robotS3ImportInstructionsSchema);
-export const interpolatableRobotS3ImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotS3ImportInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotS3ImportInstructionsSchema);
+export const { withHiddenFields: robotS3ImportInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotS3ImportInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotS3ImportInstructionsWithHiddenFieldsSchema, } = robotDefinition;

package/dist/v3/robots/s3-store.d.ts

@@ -1,9 +1,10 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinitionWithHiddenFields, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v3';
 export declare const meta: RobotMetaInput;
 export declare const robotS3StoreInstructionsSchema: 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>;
@@ -77,19 +78,19 @@ export declare const robotS3StoreInstructionsSchema: z.ZodObject<{
     session_token: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/s3/store";
     result: boolean;
+    robot: "/s3/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     host: string;
     headers: Record<string, string>;
     url_prefix: string;
-    acl: "public" | "private" | "public-read" | "bucket-default";
+    acl: "private" | "public-read" | "bucket-default" | "public";
     check_integrity: boolean;
     tags: Record<string, string>;
     no_vhost: boolean;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -104,6 +105,7 @@ export declare const robotS3StoreInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
@@ -116,7 +118,7 @@ export declare const robotS3StoreInstructionsSchema: z.ZodObject<{
     robot: "/s3/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -131,8 +133,9 @@ export declare const robotS3StoreInstructionsSchema: 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;
@@ -144,15 +147,20 @@ export declare const robotS3StoreInstructionsSchema: z.ZodObject<{
     headers?: Record<string, string> | undefined;
     sign_urls_for?: number | undefined;
     url_prefix?: string | undefined;
-    acl?: "public" | "private" | "public-read" | "bucket-default" | undefined;
+    acl?: "private" | "public-read" | "bucket-default" | "public" | undefined;
     check_integrity?: boolean | undefined;
     tags?: Record<string, string> | undefined;
     no_vhost?: boolean | undefined;
     session_token?: string | undefined;
 }>;
+declare const hiddenFields: {
+    skip_region_lookup: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const robotDefinition: RobotDefinitionWithHiddenFields<typeof robotS3StoreInstructionsSchema.shape, typeof hiddenFields>;
 export declare const robotS3StoreInstructionsWithHiddenFieldsSchema: 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")[]>>;
@@ -226,17 +234,18 @@ export declare const robotS3StoreInstructionsWithHiddenFieldsSchema: z.ZodObject
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/s3/store";
+    user_meta: Record<string, unknown>;
     force_accept: boolean;
     ignore_errors: string[];
     host: string;
     headers: Record<string, string>;
     url_prefix: string;
-    acl: "public" | "private" | "public-read" | "bucket-default";
+    acl: "private" | "public-read" | "bucket-default" | "public";
     check_integrity: boolean;
     tags: Record<string, string>;
     no_vhost: boolean;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -251,8 +260,8 @@ export declare const robotS3StoreInstructionsWithHiddenFieldsSchema: 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;
-    result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
     credentials?: string | undefined;
     bucket?: string | undefined;
@@ -265,7 +274,7 @@ export declare const robotS3StoreInstructionsWithHiddenFieldsSchema: z.ZodObject
     robot: "/s3/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: boolean | "debug" | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -280,8 +289,9 @@ export declare const robotS3StoreInstructionsWithHiddenFieldsSchema: 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 | "debug" | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
@@ -293,19 +303,16 @@ export declare const robotS3StoreInstructionsWithHiddenFieldsSchema: z.ZodObject
     headers?: Record<string, string> | undefined;
     sign_urls_for?: number | undefined;
     url_prefix?: string | undefined;
-    acl?: "public" | "private" | "public-read" | "bucket-default" | undefined;
+    acl?: "private" | "public-read" | "bucket-default" | "public" | undefined;
     check_integrity?: boolean | undefined;
     tags?: Record<string, string> | undefined;
     no_vhost?: boolean | undefined;
     session_token?: string | undefined;
     skip_region_lookup?: boolean | undefined;
-}>;
-export type RobotS3StoreInstructions = z.infer<typeof robotS3StoreInstructionsSchema>;
-export type RobotS3StoreInstructionsInput = z.input<typeof robotS3StoreInstructionsSchema>;
-export type RobotS3StoreInstructionsWithHiddenFields = z.infer<typeof robotS3StoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotS3StoreInstructionsSchema: 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">>]>>;
+}>, interpolatableRobotS3StoreInstructionsSchema: 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]>>;
@@ -376,8 +383,9 @@ export declare const interpolatableRobotS3StoreInstructionsSchema: z.ZodObject<{
     session_token: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     path: string;
-    robot: "/s3/store";
     result: string | boolean;
+    robot: "/s3/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     host: string;
@@ -388,7 +396,6 @@ export declare const interpolatableRobotS3StoreInstructionsSchema: z.ZodObject<{
     tags: Record<string, string>;
     no_vhost: string | boolean;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -403,6 +410,7 @@ export declare const interpolatableRobotS3StoreInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
@@ -415,7 +423,7 @@ export declare const interpolatableRobotS3StoreInstructionsSchema: z.ZodObject<{
     robot: "/s3/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -430,8 +438,9 @@ export declare const interpolatableRobotS3StoreInstructionsSchema: z.ZodObject<{
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | "true" | "false" | Record<string, boolean | "true" | "false"> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
+    user_meta?: Record<string, unknown> | undefined;
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
@@ -448,12 +457,10 @@ export declare const interpolatableRobotS3StoreInstructionsSchema: z.ZodObject<{
     tags?: Record<string, string> | undefined;
     no_vhost?: string | boolean | undefined;
     session_token?: string | undefined;
-}>;
-export type InterpolatableRobotS3StoreInstructions = InterpolatableRobotS3StoreInstructionsInput;
-export type InterpolatableRobotS3StoreInstructionsInput = z.input<typeof interpolatableRobotS3StoreInstructionsSchema>;
-export declare const interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchema: 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">>]>>;
+}>, interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchema: 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")[]>]>>;
@@ -526,6 +533,7 @@ export declare const interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchem
 }, "strict", z.ZodTypeAny, {
     path: string;
     robot: "/s3/store";
+    user_meta: Record<string, unknown>;
     force_accept: string | boolean;
     ignore_errors: string | string[];
     host: string;
@@ -536,7 +544,7 @@ export declare const interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchem
     tags: Record<string, string>;
     no_vhost: string | boolean;
     key?: string | undefined;
-    interpolate?: boolean | Record<string, boolean> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -551,8 +559,8 @@ export declare const interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchem
         bundle_steps?: boolean | undefined;
         group_by_original?: boolean | undefined;
     } | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
-    result?: string | boolean | undefined;
     queue?: string | undefined;
     credentials?: string | undefined;
     bucket?: string | undefined;
@@ -565,7 +573,7 @@ export declare const interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchem
     robot: "/s3/store";
     path?: string | undefined;
     key?: string | undefined;
-    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    result?: string | boolean | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -580,8 +588,9 @@ export declare const interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchem
         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;
@@ -600,6 +609,13 @@ export declare const interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchem
     session_token?: string | undefined;
     skip_region_lookup?: string | boolean | undefined;
 }>;
-export type InterpolatableRobotS3StoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotS3StoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotS3StoreInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotS3StoreInstructions = Instructions['output'];
+export type RobotS3StoreInstructionsInput = Instructions['input'];
+export type RobotS3StoreInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotS3StoreInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotS3StoreInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotS3StoreInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotS3StoreInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=s3-store.d.ts.map

package/dist/v3/robots/s3-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"s3-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/s3-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoHhC,CAAA;AAEX,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU1D,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AACrF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC1F,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,KAAK,CAC5D,OAAO,8CAA8C,CACtD,CAAA;AAED,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAExD,CAAA;AACD,MAAM,MAAM,sCAAsC,GAAG,2CAA2C,CAAA;AAEhG,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,4CAA4C,CACpD,CAAA;AAED,eAAO,MAAM,4DAA4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAExE,CAAA;AACD,MAAM,MAAM,sDAAsD,GAAG,CAAC,CAAC,KAAK,CAC1E,OAAO,4DAA4D,CACpE,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,4DAA4D,CACpE,CAAA"}
+{"version":3,"file":"s3-store.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/s3-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAgB1B,eAAO,MAAM,IAAI,EAAE,cAYlB,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4GhC,CAAA;AAEX,QAAA,MAAM,YAAY;;CAOjB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,+BAA+B,CAC3D,OAAO,8BAA8B,CAAC,KAAK,EAC3C,OAAO,YAAY,CAC8D,CAAA;AAEnF,eAAO,MACa,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAChD,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC5B,4DAA4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC3E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,wBAAwB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAC7D,MAAM,MAAM,6BAA6B,GAAG,YAAY,CAAC,OAAO,CAAC,CAAA;AACjE,MAAM,MAAM,wCAAwC,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACnF,MAAM,MAAM,sCAAsC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACxF,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC7F,MAAM,MAAM,sDAAsD,GAChE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,2DAA2D,GACrE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}