transloadit 4.12.0 → 4.13.1

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

@@ -1 +1 @@
-{"version":3,"file":"file-serve.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,IAAI,EAAE,cA2ClB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgFlC,CAAA;AAEX,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGzD,CAAA;AAEJ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACzF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAC9F,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":"file-serve.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,IAAI,EAAE,cA2ClB,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwFlC,CAAA;AAEX,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGzD,CAAA;AAEJ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AACzF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAC9F,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"}

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

@@ -61,11 +61,11 @@ Also consider configuring caching headers and cache-control directives to contro
 You can leverage [signed Smart CDN URLs](/docs/api/authentication/#smart-cdn) to avoid abuse of our encoding platform. Below is a quick Node.js example using our Node SDK, but there are [examples for other languages and SDKs](/docs/api/authentication/#example-code) as well.
 
 \`\`\`javascript
-// yarn add transloadit
+// yarn add @transloadit/node
 // or
-// npm install --save transloadit
+// npm install --save @transloadit/node
 
-import { Transloadit } from 'transloadit'
+import { Transloadit } from '@transloadit/node'
 
 const transloadit = new Transloadit({
   authKey: 'YOUR_TRANSLOADIT_KEY',
@@ -103,6 +103,12 @@ An optional duration in seconds that the served file should be cached. When set,
 
 This is useful for controlling data retention in CDNs. For instance, if your temporary files are deleted after 24 hours, you can set \`cache_duration\` to \`86400\` to ensure cached copies also expire within that window.
 `),
+    download_name: z
+        .string()
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: reject header-injection control characters, not literal text.
+        .regex(/^[^/\\\u0000-\u001f\u007f-\u009f]{0,255}$/u)
+        .optional()
+        .describe('Serve as an attachment using this Unicode filename. Empty or omitted keeps inline delivery. Overrides a Content-Disposition header without changing the bytes or Range support.'),
     headers: z
         .record(z.string())
         .default({

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

@@ -1 +1 @@
-{"version":3,"file":"file-serve.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-serve.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAErF,MAAM,CAAC,MAAM,IAAI,GAAmB;IAClC,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,IAAI;IACrB,YAAY,EAAE,EAAE;IAChB,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,OAAO,EAAE;gBACP,KAAK,EAAE,eAAe;gBACtB,GAAG,EAAE,WAAW;gBAChB,KAAK,EAAE,GAAG;gBACV,MAAM,EAAE,GAAG;gBACX,eAAe,EAAE,KAAK;aACvB;YACD,MAAM,EAAE;gBACN,KAAK,EAAE,aAAa;gBACpB,GAAG,EAAE,SAAS;gBACd,cAAc,EAAE,KAAK;aACtB;SACF;KACF;IACD,wBAAwB,EAAE,uEAAuE;IACjG,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,gBAAgB,EAAE,8BAA8B;IAChD,YAAY,EAAE,OAAO;IACrB,YAAY,EAAE,aAAa;IAC3B,aAAa,EAAE,6BAA6B;IAC5C,YAAY,EAAE,kBAAkB;IAChC,UAAU,EAAE,CAAC;IACb,KAAK,EAAE,6BAA6B;IACpC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;IACzB,IAAI,EAAE,gBAAgB;IACtB,WAAW,EAAE,CAAC;IACd,gBAAgB,EAAE,kBAAkB;IACpC,cAAc,EAAE,CAAC;IACjB,kBAAkB,EAAE,KAAK;IACzB,qBAAqB,EAAE,IAAI;IAC3B,wBAAwB,EAAE,IAAI;IAC9B,mBAAmB,EAAE,KAAK;IAC1B,UAAU,EAAE,KAAK;IACjB,KAAK,EAAE,IAAI;IACX,iDAAiD,EAAE,KAAK;CACzD,CAAA;AAED,MAAM,CAAC,MAAM,gCAAgC,GAAG,SAAS;KACtD,KAAK,CAAC,QAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6C5C,CAAC;IACE,cAAc,EAAE,CAAC;SACd,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CAAC;;;;CAIf,CAAC;IACE,OAAO,EAAE,CAAC;SACP,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SAClB,OAAO,CAAC;QACP,8BAA8B,EAC5B,2HAA2H;QAC7H,8BAA8B,EAAE,iCAAiC;QACjE,6BAA6B,EAAE,GAAG;QAClC,+BAA+B,EAC7B,wEAAwE;QAC1E,eAAe,EAAE,wCAAwC;QACzD,cAAc,EAAE,6BAA6B;QAC7C,sBAAsB,EAAE,GAAG;QAC3B,uBAAuB,EAAE,GAAG;QAC5B,eAAe,EAAE,OAAO;KACzB,CAAC;SACD,QAAQ,CAAC;;;;CAIf,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,gDAAgD,GAC3D,gCAAgC,CAAC,MAAM,CAAC;IACtC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,gCAAgC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;CAChG,CAAC,CAAA;AAQJ,MAAM,CAAC,MAAM,8CAA8C,GAAG,gBAAgB,CAC5E,gCAAgC,CACjC,CAAA;AAOD,MAAM,CAAC,MAAM,8DAA8D,GAAG,gBAAgB,CAC5F,gDAAgD,CACjD,CAAA"}
+{"version":3,"file":"file-serve.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/file-serve.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,195 @@
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod';
+/** Cross-field validation runs after interpolation-aware parsing at the Assembly Step boundary. */
+export declare function refineTransloaditImportSelector(step: {
+    robot: string;
+    path?: unknown;
+    asset_id?: unknown;
+    version_id?: unknown;
+    recursive?: unknown;
+}, context: z.RefinementCtx): void;
+export declare const meta: RobotMetaInput;
+export declare const robotTransloaditImportInstructionsSchema: 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">>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+    queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+} & {
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+    import_on_errors: z.ZodDefault<z.ZodArray<z.ZodEnum<["meta"]>, "many">>;
+} & {
+    robot: z.ZodLiteral<"/transloadit/import">;
+    path: z.ZodOptional<z.ZodString>;
+    asset_id: z.ZodOptional<z.ZodString>;
+    version_id: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    robot: "/transloadit/import";
+    result: boolean;
+    force_accept: boolean;
+    ignore_errors: string[];
+    force_name: string | string[] | null;
+    import_on_errors: "meta"[];
+    recursive: boolean;
+    path?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    queue?: "batch" | undefined;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}, {
+    robot: "/transloadit/import";
+    path?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    result?: boolean | 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;
+    recursive?: boolean | undefined;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}>;
+export declare const robotTransloaditImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
+    queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>>;
+    import_on_errors: z.ZodDefault<z.ZodArray<z.ZodEnum<["meta"]>, "many">>;
+    robot: z.ZodLiteral<"/transloadit/import">;
+    path: z.ZodOptional<z.ZodString>;
+    asset_id: z.ZodOptional<z.ZodString>;
+    version_id: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+} & {
+    result: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, "strict", z.ZodTypeAny, {
+    robot: "/transloadit/import";
+    force_accept: boolean;
+    ignore_errors: string[];
+    force_name: string | string[] | null;
+    import_on_errors: "meta"[];
+    recursive: boolean;
+    path?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | undefined;
+    queue?: "batch" | undefined;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}, {
+    robot: "/transloadit/import";
+    path?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
+    output_meta?: boolean | string[] | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | 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;
+    recursive?: boolean | undefined;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}>;
+export type RobotTransloaditImportInstructions = z.infer<typeof robotTransloaditImportInstructionsSchema>;
+export type RobotTransloaditImportInstructionsWithHiddenFields = z.infer<typeof robotTransloaditImportInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotTransloaditImportInstructionsSchema: 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">>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<["meta"]>]>, "many">]>>;
+    robot: z.ZodLiteral<"/transloadit/import">;
+    path: z.ZodOptional<z.ZodString>;
+    asset_id: z.ZodOptional<z.ZodString>;
+    version_id: z.ZodOptional<z.ZodString>;
+} & {
+    recursive: z.ZodUnion<[z.ZodDefault<z.ZodBoolean>, z.ZodEffects<z.ZodEnum<["true", "false"]>, boolean, "false" | "true">, z.ZodType<`\${${string}}`, z.ZodTypeDef, `\${${string}}`>]>;
+}, "strict", z.ZodTypeAny, {
+    robot: "/transloadit/import";
+    result: string | boolean;
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    force_name: string | string[] | null;
+    import_on_errors: string | string[];
+    recursive: boolean | `\${${string}}`;
+    path?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
+    output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
+    queue?: string | undefined;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}, {
+    robot: "/transloadit/import";
+    path?: 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;
+    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;
+    recursive?: boolean | "false" | "true" | `\${${string}}` | undefined;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}>;
+export type InterpolatableRobotTransloaditImportInstructions = InterpolatableRobotTransloaditImportInstructionsInput;
+export type InterpolatableRobotTransloaditImportInstructionsInput = z.input<typeof interpolatableRobotTransloaditImportInstructionsSchema>;
+export declare const interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema: 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">>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>]>>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import", "execute"]>, "many">]>, string[], boolean | ("import" | "meta" | "execute")[]>]>>;
+    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<["meta"]>]>, "many">]>>;
+    robot: z.ZodLiteral<"/transloadit/import">;
+    path: z.ZodOptional<z.ZodString>;
+    asset_id: z.ZodOptional<z.ZodString>;
+    version_id: 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]>>]>>;
+} & {
+    recursive: z.ZodUnion<[z.ZodDefault<z.ZodBoolean>, z.ZodEffects<z.ZodEnum<["true", "false"]>, boolean, "false" | "true">, z.ZodType<`\${${string}}`, z.ZodTypeDef, `\${${string}}`>]>;
+}, "strict", z.ZodTypeAny, {
+    robot: "/transloadit/import";
+    force_accept: string | boolean;
+    ignore_errors: string | string[];
+    force_name: string | string[] | null;
+    import_on_errors: string | string[];
+    recursive: boolean | `\${${string}}`;
+    path?: 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;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}, {
+    robot: "/transloadit/import";
+    path?: 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;
+    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;
+    recursive?: boolean | "false" | "true" | `\${${string}}` | undefined;
+    asset_id?: string | undefined;
+    version_id?: string | undefined;
+}>;
+export type InterpolatableRobotTransloaditImportInstructionsWithHiddenFields = InterpolatableRobotTransloaditImportInstructionsWithHiddenFieldsInput;
+export type InterpolatableRobotTransloaditImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=transloadit-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transloadit-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/transloadit-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAYvB,mGAAmG;AACnG,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,EACD,OAAO,EAAE,CAAC,CAAC,aAAa,GACvB,IAAI,CAkBN;AAOD,eAAO,MAAM,IAAI,EAAE,cAiClB,CAAA;AAED,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1C,CAAA;AAEX,eAAO,MAAM,wDAAwD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjE,CAAA;AAEJ,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,wDAAwD,CAChE,CAAA;AAED,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYjE,CAAA;AACF,MAAM,MAAM,gDAAgD,GAC1D,qDAAqD,CAAA;AAEvD,MAAM,MAAM,qDAAqD,GAAG,CAAC,CAAC,KAAK,CACzE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,sEAAsE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG/E,CAAA;AACJ,MAAM,MAAM,gEAAgE,GAC1E,qEAAqE,CAAA;AACvE,MAAM,MAAM,qEAAqE,GAAG,CAAC,CAAC,KAAK,CACzF,OAAO,sEAAsE,CAC9E,CAAA"}

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

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { damIdSchema } from "../storageAsset.js";
+import { booleanStringSchema, interpolateRobot, interpolationSchemaFull, recursive, robotBase, robotImport, } from "./_instructions-primitives.js";
+/** Cross-field validation runs after interpolation-aware parsing at the Assembly Step boundary. */
+export function refineTransloaditImportSelector(step, context) {
+    if (step.robot !== '/transloadit/import')
+        return;
+    const hasPath = step.path !== undefined;
+    const hasAsset = step.asset_id !== undefined;
+    if (hasPath === hasAsset || (step.version_id !== undefined && !hasAsset)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [step.version_id !== undefined && !hasAsset ? 'version_id' : 'asset_id'],
+            message: 'Select either path, or asset_id with an optional version_id.',
+        });
+    }
+    if (hasAsset && step.recursive === true) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['recursive'],
+            message: 'Recursive imports require a path, not an asset_id.',
+        });
+    }
+}
+const recursiveDescription = `
+Whether to import files from subfolders and sub-subfolders when \`path\` is a folder. By default
+only the folder's own files are imported.
+`;
+export const meta = {
+    bytescount: 10,
+    discount_factor: 0.1,
+    discount_pct: 90,
+    example_code: {
+        steps: {
+            imported: {
+                robot: '/transloadit/import',
+                path: 'photos/cat.jpg',
+            },
+        },
+    },
+    example_code_description: 'Import a file from Transloadit Storage:',
+    has_small_icon: true,
+    isAllowedForUrlTransform: true,
+    isInternal: false,
+    minimum_charge: 0,
+    name: 'TransloaditImportRobot',
+    output_factor: 1,
+    override_lvl1: 'File Importing',
+    priceFactor: 10,
+    purpose_sentence: 'imports files from Transloadit Storage',
+    purpose_verb: 'import',
+    purpose_word: 'Transloadit Storage',
+    purpose_words: 'Import files from Transloadit Storage',
+    queueSlotCount: 10,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
+    service_slug: 'file-importing',
+    slot_count: 10,
+    stage: 'beta',
+    title: 'Import files from Transloadit Storage',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+export const robotTransloaditImportInstructionsSchema = robotBase
+    .merge(robotImport)
+    .extend({
+    robot: z.literal('/transloadit/import').describe(`
+Imports files from your Workspace's Transloadit Storage. Select a mutable location with
+\`path\`, or a logical asset with \`asset_id\`. Add \`version_id\` to pin the exact stored bytes.
+IDs remain subject to Workspace access and version retention.
+`),
+    path: z
+        .string()
+        .optional()
+        .describe(`
+The current file or folder location, for example \`photos/cat.jpg\`. Use either \`path\` or
+\`asset_id\`, not both. Renaming makes an old path stale; overwriting changes what it imports.
+`),
+    asset_id: damIdSchema.optional().describe(`
+The stored asset's stable ID. Without \`version_id\`, imports its current version even after
+renaming or moving it. Cannot be combined with \`path\` or recursive folder imports.
+`),
+    version_id: damIdSchema.optional().describe(`
+The exact retained version of \`asset_id\` to import. Requires \`asset_id\`; a missing or deleted
+version never falls back to the current version.
+`),
+    recursive: recursive.describe(recursiveDescription),
+})
+    .strict();
+export const robotTransloaditImportInstructionsWithHiddenFieldsSchema = robotTransloaditImportInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotTransloaditImportInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotTransloaditImportInstructionsSchema = interpolateRobot(robotTransloaditImportInstructionsSchema).extend({
+    // The generic boolean interpolator changes literal false to true. Keep Storage's documented
+    // false default intact; unresolved variables are validated after uploader interpolation.
+    recursive: z
+        .union([
+        recursive,
+        booleanStringSchema.transform((value) => value === 'true'),
+        interpolationSchemaFull,
+    ])
+        .describe(recursiveDescription),
+});
+export const interpolatableRobotTransloaditImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotTransloaditImportInstructionsWithHiddenFieldsSchema).extend({
+    recursive: interpolatableRobotTransloaditImportInstructionsSchema.shape.recursive,
+});
+//# sourceMappingURL=transloadit-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transloadit-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/transloadit-import.ts"],"names":[],"mappings":"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"}