@transloadit/zod 4.1.5 → 4.1.6

package/dist/v4/robots/text-translate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-translate.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/text-translate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,eAAO,MAAM,IAAI,EAAE,cAqDlB,CAAA;AA0HD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2BtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,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"}

package/dist/v4/robots/text-translate.js

@@ -0,0 +1,210 @@
+import { z } from 'zod/v4';
+import { aiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+export const meta = {
+    allowed_for_url_transform: true,
+    bytescount: 1,
+    discount_factor: 1,
+    discount_pct: 0,
+    example_code: {
+        steps: {
+            translated: {
+                robot: '/text/translate',
+                use: ':original',
+                target_language: 'de',
+                provider: 'aws',
+            },
+        },
+    },
+    example_code_description: 'Translate uploaded text file contents to German:',
+    extended_description: `
+> [!Warning]
+> This <dfn>Robot</dfn> uses third-party AI services. They may tweak their models over time, giving different responses for the same input media. Avoid relying on exact responses in your tests and application.
+
+## Supported languages
+
+{%- for provider in text_translate_languages %}
+
+### {{provider[0] | upcase }}
+
+<!-- prettier-ignore -->
+{%- for language in provider[1] %}
+  {{ language }}{% unless forloop.last %},{% endunless %}
+{%- endfor %}
+
+{%- endfor %}
+`,
+    minimum_charge: 1048576,
+    output_factor: 1,
+    override_lvl1: 'Artificial Intelligence',
+    purpose_sentence: 'translates text in documents',
+    purpose_verb: 'translate',
+    purpose_word: 'text',
+    purpose_words: 'Translate text in documents',
+    service_slug: 'artificial-intelligence',
+    slot_count: 10,
+    title: 'Translate text',
+    typical_file_size_mb: 1,
+    typical_file_type: 'document',
+    name: 'TextTranslateRobot',
+    priceFactor: 0.00008,
+    queueSlotCount: 10,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+const translatableLanguages = z
+    .enum([
+    'af',
+    'am',
+    'ar',
+    'az',
+    'be',
+    'bg',
+    'bn',
+    'bs',
+    'ca',
+    'ceb',
+    'co',
+    'cs',
+    'cy',
+    'da',
+    'de',
+    'el',
+    'en',
+    'en-US',
+    'eo',
+    'es',
+    'es-MX',
+    'et',
+    'eu',
+    'fa',
+    'fa-AF',
+    'fi',
+    'fr',
+    'fr-CA',
+    'fy',
+    'ga',
+    'gd',
+    'gl',
+    'gu',
+    'ha',
+    'haw',
+    'he',
+    'hi',
+    'hmn',
+    'hr',
+    'ht',
+    'hu',
+    'hy',
+    'id',
+    'ig',
+    'is',
+    'it',
+    'iw',
+    'ja',
+    'jv',
+    'ka',
+    'kk',
+    'km',
+    'kn',
+    'ko',
+    'ku',
+    'ky',
+    'la',
+    'lb',
+    'lo',
+    'lt',
+    'lv',
+    'mg',
+    'mi',
+    'mk',
+    'ml',
+    'mn',
+    'mr',
+    'ms',
+    'mt',
+    'my',
+    'ne',
+    'nl',
+    'no',
+    'ny',
+    'or',
+    'pa',
+    'pl',
+    'ps',
+    'pt',
+    'ro',
+    'ru',
+    'rw',
+    'sd',
+    'si',
+    'sk',
+    'sl',
+    'sm',
+    'sn',
+    'so',
+    'sq',
+    'sr',
+    'st',
+    'su',
+    'sv',
+    'sw',
+    'ta',
+    'te',
+    'tg',
+    'th',
+    'tk',
+    'tl',
+    'tr',
+    'tt',
+    'ug',
+    'uk',
+    'ur',
+    'uz',
+    'vi',
+    'xh',
+    'yi',
+    'yo',
+    'zh',
+    'zh-CN',
+    'zh-TW',
+    'zu',
+])
+    .default('en');
+export const robotTextTranslateInstructionsSchema = robotBase
+    .merge(robotUse)
+    .extend({
+    robot: z.literal('/text/translate').describe(`
+You can use the text that we return in your application, or you can pass the text down to other <dfn>Robots</dfn> to add a translated subtitle track to a video for example.
+
+> [!Note]
+> **This <dfn>Robot</dfn> accepts only files with a \`text/*\` MIME-type,** including plain text and Markdown. For documents in other formats, use [🤖/document/convert](/docs/robots/document-convert/) to first convert them into a compatible text format before proceeding.
+`),
+    provider: aiProviderSchema.describe(`
+Which AI provider to leverage. Valid values are \`"aws"\` (Amazon Web Services) and \`"gcp"\` (Google Cloud Platform).
+
+Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+`),
+    target_language: translatableLanguages.describe(`
+The desired language to translate to.
+
+If the exact language can't be found, a generic variant can be fallen back to. For example, if you specify \`"en-US"\`, "en" will be used instead. Please consult the list of supported languages for each provider.
+`),
+    source_language: translatableLanguages.describe(`
+The desired language to translate from.
+
+By default, both providers will detect this automatically, but there are cases where specifying the source language prevents ambiguities.
+
+If the exact language can't be found, a generic variant can be fallen back to. For example, if you specify \`"en-US"\`, "en" will be used instead. Please consult the list of supported languages for each provider.
+`),
+})
+    .strict();
+export const robotTextTranslateInstructionsWithHiddenFieldsSchema = robotTextTranslateInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotTextTranslateInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotTextTranslateInstructionsSchema = interpolateRobot(robotTextTranslateInstructionsSchema);
+export const interpolatableRobotTextTranslateInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTextTranslateInstructionsWithHiddenFieldsSchema);

package/dist/v4/robots/tigris-import.d.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod/v4';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotTigrisImportInstructionsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+    queue: z.ZodOptional<z.ZodEnum<{
+        batch: "batch";
+    }>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        import: "import";
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/import">;
+    path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    page_number: z.ZodDefault<z.ZodNumber>;
+    files_per_page: z.ZodDefault<z.ZodNumber>;
+    return_file_stubs: z.ZodDefault<z.ZodBoolean>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const robotTigrisImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    queue: z.ZodOptional<z.ZodEnum<{
+        batch: "batch";
+    }>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        import: "import";
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/import">;
+    path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    page_number: z.ZodDefault<z.ZodNumber>;
+    files_per_page: z.ZodDefault<z.ZodNumber>;
+    return_file_stubs: z.ZodDefault<z.ZodBoolean>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, z.core.$strict>;
+export type RobotTigrisImportInstructions = z.infer<typeof robotTigrisImportInstructionsSchema>;
+export type RobotTigrisImportInstructionsWithHiddenFields = z.infer<typeof robotTigrisImportInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotTigrisImportInstructionsSchema: 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>]>]>>;
+    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        batch: "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>]>]>>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        import: "import";
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/import">;
+    path: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>;
+    recursive: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    page_number: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    files_per_page: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    return_file_stubs: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type InterpolatableRobotTigrisImportInstructions = InterpolatableRobotTigrisImportInstructionsInput;
+export type InterpolatableRobotTigrisImportInstructionsInput = z.input<typeof interpolatableRobotTigrisImportInstructionsSchema>;
+export declare const interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema: 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>]>]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        batch: "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>]>]>>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        import: "import";
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/import">;
+    path: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>;
+    recursive: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    page_number: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    files_per_page: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    return_file_stubs: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotTigrisImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotTigrisImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=tigris-import.d.ts.map

package/dist/v4/robots/tigris-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tigris-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/tigris-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAanE,eAAO,MAAM,IAAI,EAAE,cAuClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;kBAmCrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;kBAK5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/v4/robots/tigris-import.js

@@ -0,0 +1,84 @@
+import { z } from 'zod/v4';
+import { files_per_page, interpolateRobot, page_number, path, recursive, return_file_stubs, robotBase, robotImport, tigrisBase, } 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: '/tigris/import',
+                credentials: 'YOUR_TIGRIS_CREDENTIALS',
+                path: 'path/to/files/',
+                recursive: true,
+            },
+        },
+    },
+    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 Tigris bucket',
+    purpose_verb: 'import',
+    purpose_word: 'Tigris',
+    purpose_words: 'Import files from Tigris',
+    requires_credentials: true,
+    service_slug: 'file-importing',
+    slot_count: 20,
+    title: 'Import files from Tigris',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+    name: 'TigrisImportRobot',
+    priceFactor: 6.6666,
+    queueSlotCount: 20,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: false,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+    stage: 'ga',
+};
+export const robotTigrisImportInstructionsSchema = robotBase
+    .merge(robotImport)
+    .merge(tigrisBase)
+    .extend({
+    robot: z.literal('/tigris/import'),
+    path: path.describe(`
+The path in your bucket to the specific file or directory. If the path points to a file, only this file will be imported. For example: \`images/avatar.jpg\`.
+
+If it points to a directory, indicated by a trailing slash (\`/\`), then all files that are direct descendants of this directory will be imported. For example: \`images/\`.
+
+Directories are **not** imported recursively. If you want to import files from subdirectories and sub-subdirectories, enable the \`recursive\` parameter.
+
+If you want to import all files from the root directory, please use \`/\` as the value here. In this case, make sure all your objects belong to a path. If you have objects in the root of your bucket that aren't prefixed with \`/\`, you'll receive an error: \`A client error (NoSuchKey) occurred when calling the GetObject operation: The specified key does not exist.\`
+
+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.
+`),
+    page_number: page_number.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\`.
+
+When doing big imports, make sure no files are added or removed from other scripts within your path, otherwise you might get weird results with the pagination.
+`),
+    files_per_page: files_per_page.describe(`
+The pagination page size. This only works when recursive is \`true\` for now, in order to not break backwards compatibility in non-recursive imports.
+`),
+    return_file_stubs,
+    bucket_region: z
+        .string()
+        .optional()
+        .describe('The region of your Tigris bucket. This is optional as it can often be derived.'),
+})
+    .strict();
+export const robotTigrisImportInstructionsWithHiddenFieldsSchema = robotTigrisImportInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotTigrisImportInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotTigrisImportInstructionsSchema = interpolateRobot(robotTigrisImportInstructionsSchema);
+export const interpolatableRobotTigrisImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTigrisImportInstructionsWithHiddenFieldsSchema);

package/dist/v4/robots/tigris-store.d.ts

@@ -0,0 +1,170 @@
+import { z } from 'zod/v4';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotTigrisStoreInstructionsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+    queue: z.ZodOptional<z.ZodEnum<{
+        batch: "batch";
+    }>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/store">;
+    path: z.ZodDefault<z.ZodString>;
+    acl: z.ZodDefault<z.ZodEnum<{
+        private: "private";
+        "public-read": "public-read";
+    }>>;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sign_urls_for: z.ZodOptional<z.ZodNumber>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const robotTigrisStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    queue: z.ZodOptional<z.ZodEnum<{
+        batch: "batch";
+    }>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/store">;
+    path: z.ZodDefault<z.ZodString>;
+    acl: z.ZodDefault<z.ZodEnum<{
+        private: "private";
+        "public-read": "public-read";
+    }>>;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sign_urls_for: z.ZodOptional<z.ZodNumber>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, z.core.$strict>;
+export type RobotTigrisStoreInstructions = z.infer<typeof robotTigrisStoreInstructionsSchema>;
+export type RobotTigrisStoreInstructionsWithHiddenFields = z.infer<typeof robotTigrisStoreInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotTigrisStoreInstructionsSchema: 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>]>]>>;
+    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        batch: "batch";
+    }>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/store">;
+    path: z.ZodDefault<z.ZodString>;
+    acl: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        private: "private";
+        "public-read": "public-read";
+    }>]>>;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sign_urls_for: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type InterpolatableRobotTigrisStoreInstructions = InterpolatableRobotTigrisStoreInstructionsInput;
+export type InterpolatableRobotTigrisStoreInstructionsInput = z.input<typeof interpolatableRobotTigrisStoreInstructionsSchema>;
+export declare const interpolatableRobotTigrisStoreInstructionsWithHiddenFieldsSchema: 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>]>]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        batch: "batch";
+    }>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    credentials: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    robot: z.ZodLiteral<"/tigris/store">;
+    path: z.ZodDefault<z.ZodString>;
+    acl: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        private: "private";
+        "public-read": "public-read";
+    }>]>>;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sign_urls_for: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    bucket_region: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotTigrisStoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotTigrisStoreInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotTigrisStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotTigrisStoreInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=tigris-store.d.ts.map

package/dist/v4/robots/tigris-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tigris-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/tigris-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyCpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK3D,CAAA;AAEJ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5D,CAAA;AACD,MAAM,MAAM,0CAA0C,GACpD,+CAA+C,CAAA;AAEjD,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,gDAAgD,CACxD,CAAA;AAED,eAAO,MAAM,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5E,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,gEAAgE,CACxE,CAAA;AACD,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,gEAAgE,CACxE,CAAA"}