@transloadit/zod 4.5.0 → 5.0.0

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotDigitaloceanImportInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -36,15 +37,17 @@ export declare const robotDigitaloceanImportInstructionsSchema: z.ZodObject<{
     files_per_page: z.ZodDefault<z.ZodNumber>;
     return_file_stubs: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotDigitaloceanImportInstructionsSchema.shape>;
 export declare const robotDigitaloceanImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -70,30 +73,28 @@ export declare const robotDigitaloceanImportInstructionsWithHiddenFieldsSchema:
     files_per_page: z.ZodDefault<z.ZodNumber>;
     return_file_stubs: z.ZodDefault<z.ZodBoolean>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotDigitaloceanImportInstructions = z.infer<typeof robotDigitaloceanImportInstructionsSchema>;
-export type RobotDigitaloceanImportInstructionsWithHiddenFields = z.infer<typeof robotDigitaloceanImportInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDigitaloceanImportInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDigitaloceanImportInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    force_name: z.ZodPrefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
-    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    import_on_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
     }>]>>]>>;
     credentials: z.ZodOptional<z.ZodString>;
@@ -103,33 +104,31 @@ export declare const interpolatableRobotDigitaloceanImportInstructionsSchema: z.
     secret: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/digitalocean/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]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotDigitaloceanImportInstructions = InterpolatableRobotDigitaloceanImportInstructionsInput;
-export type InterpolatableRobotDigitaloceanImportInstructionsInput = z.input<typeof interpolatableRobotDigitaloceanImportInstructionsSchema>;
-export declare const interpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    recursive: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    page_number: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    files_per_page: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    return_file_stubs: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>, interpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    force_name: z.ZodPrefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
-    import_on_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    import_on_errors: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
     }>]>>]>>;
     credentials: z.ZodOptional<z.ZodString>;
@@ -139,12 +138,18 @@ export declare const interpolatableRobotDigitaloceanImportInstructionsWithHidden
     secret: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/digitalocean/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]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    recursive: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    page_number: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    files_per_page: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    return_file_stubs: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotDigitaloceanImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDigitaloceanImportInstructions = Instructions['output'];
+export type RobotDigitaloceanImportInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDigitaloceanImportInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDigitaloceanImportInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDigitaloceanImportInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=digitalocean-import.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"digitalocean-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/digitalocean-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,cAqClB,CAAA;AAED,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6B3C,CAAA;AAEX,eAAO,MAAM,yDAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKlE,CAAA;AAEJ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,yDAAyD,CACjE,CAAA;AAED,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEnE,CAAA;AACD,MAAM,MAAM,iDAAiD,GAC3D,sDAAsD,CAAA;AAExD,MAAM,MAAM,sDAAsD,GAAG,CAAC,CAAC,KAAK,CAC1E,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC7E,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,uEAAuE,CAC/E,CAAA;AACD,MAAM,MAAM,sEAAsE,GAAG,CAAC,CAAC,KAAK,CAC1F,OAAO,uEAAuE,CAC/E,CAAA"}
+{"version":3,"file":"digitalocean-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/digitalocean-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,cAWlB,CAAA;AAED,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmB3C,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,yCAAyC,CAAC,KAAK,CACQ,CAAA;AAEhE,eAAO,MACa,yDAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC3D,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAErE,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACxD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,mCAAmC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACxE,MAAM,MAAM,mDAAmD,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAC9F,MAAM,MAAM,iDAAiD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACnG,MAAM,MAAM,sDAAsD,GAChE,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,iEAAiE,GAC3E,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,sEAAsE,GAChF,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

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

@@ -1,41 +1,15 @@
 import { z } from 'zod/v4';
-import { digitalOceanBase, files_per_page, interpolateRobot, page_number, path, recursive, return_file_stubs, robotBase, robotImport, } from "./_instructions-primitives.js";
+import { createStorageImportExample, defineRobot, digitalOceanBase, path, recursiveImport, recursiveImportPageNumber, recursiveImportPageSize, return_file_stubs, robotBase, robotImport, robotImportMeta, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 10,
-    discount_factor: 0.1,
-    discount_pct: 90,
-    example_code: {
-        steps: {
-            imported: {
-                robot: '/digitalocean/import',
-                credentials: 'YOUR_DIGITALOCEAN_CREDENTIALS',
-                path: 'path/to/files/',
-                recursive: true,
-            },
-        },
-    },
+    ...robotImportMeta,
+    example_code: createStorageImportExample('/digitalocean/import', 'YOUR_DIGITALOCEAN_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 DigitalOcean Spaces',
-    purpose_verb: 'import',
     purpose_word: 'DigitalOcean Spaces',
     purpose_words: 'Import files from DigitalOcean Spaces',
-    service_slug: 'file-importing',
-    slot_count: 20,
     title: 'Import files from DigitalOcean Spaces',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'DigitalOceanImportRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 20,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: true,
-    stage: 'ga',
 };
 export const robotDigitaloceanImportInstructionsSchema = robotBase
     .merge(robotImport)
@@ -51,26 +25,11 @@ Directories are **not** imported recursively. If you want to import files from s
 
 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.
-`),
+    recursive: recursiveImport,
+    page_number: recursiveImportPageNumber,
+    files_per_page: recursiveImportPageSize,
     return_file_stubs,
 })
     .strict();
-export const robotDigitaloceanImportInstructionsWithHiddenFieldsSchema = robotDigitaloceanImportInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotDigitaloceanImportInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotDigitaloceanImportInstructionsSchema = interpolateRobot(robotDigitaloceanImportInstructionsSchema);
-export const interpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDigitaloceanImportInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotDigitaloceanImportInstructionsSchema);
+export const { withHiddenFields: robotDigitaloceanImportInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotDigitaloceanImportInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotDigitaloceanImportInstructionsWithHiddenFieldsSchema, } = robotDefinition;

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotDigitaloceanStoreInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -48,15 +49,17 @@ export declare const robotDigitaloceanStoreInstructionsSchema: z.ZodObject<{
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     sign_urls_for: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotDigitaloceanStoreInstructionsSchema.shape>;
 export declare const robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -94,24 +97,22 @@ export declare const robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: z
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     sign_urls_for: z.ZodOptional<z.ZodNumber>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-}, z.core.$strict>;
-export type RobotDigitaloceanStoreInstructions = z.infer<typeof robotDigitaloceanStoreInstructionsSchema>;
-export type RobotDigitaloceanStoreInstructionsWithHiddenFields = z.infer<typeof robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema>;
-export declare const interpolatableRobotDigitaloceanStoreInstructionsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDigitaloceanStoreInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
-    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
@@ -135,31 +136,29 @@ export declare const interpolatableRobotDigitaloceanStoreInstructionsSchema: z.Z
     key: z.ZodOptional<z.ZodString>;
     secret: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/digitalocean/store">;
-    path: z.ZodDefault<z.ZodString>;
-    url_prefix: z.ZodDefault<z.ZodString>;
-    acl: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    path: z.ZodPrefault<z.ZodString>;
+    url_prefix: z.ZodPrefault<z.ZodString>;
+    acl: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         private: "private";
         "public-read": "public-read";
     }>]>>;
-    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     sign_urls_for: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotDigitaloceanStoreInstructions = InterpolatableRobotDigitaloceanStoreInstructionsInput;
-export type InterpolatableRobotDigitaloceanStoreInstructionsInput = z.input<typeof interpolatableRobotDigitaloceanStoreInstructionsSchema>;
-export declare const interpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+}, z.core.$strict>, interpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
@@ -183,16 +182,22 @@ export declare const interpolatableRobotDigitaloceanStoreInstructionsWithHiddenF
     key: z.ZodOptional<z.ZodString>;
     secret: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/digitalocean/store">;
-    path: z.ZodDefault<z.ZodString>;
-    url_prefix: z.ZodDefault<z.ZodString>;
-    acl: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    path: z.ZodPrefault<z.ZodString>;
+    url_prefix: z.ZodPrefault<z.ZodString>;
+    acl: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         private: "private";
         "public-read": "public-read";
     }>]>>;
-    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     sign_urls_for: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotDigitaloceanStoreInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotDigitaloceanStoreInstructions = Instructions['output'];
+export type RobotDigitaloceanStoreInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotDigitaloceanStoreInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotDigitaloceanStoreInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotDigitaloceanStoreInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=digitalocean-store.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"digitalocean-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/digitalocean-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAED,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyC1C,CAAA;AAEX,eAAO,MAAM,wDAAwD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKjE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAElE,CAAA;AACD,MAAM,MAAM,gDAAgD,GAC1D,qDAAqD,CAAA;AAEvD,MAAM,MAAM,qDAAqD,GAAG,CAAC,CAAC,KAAK,CACzE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,sEAAsE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC5E,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,sEAAsE,CAC9E,CAAA;AACD,MAAM,MAAM,qEAAqE,GAAG,CAAC,CAAC,KAAK,CACzF,OAAO,sEAAsE,CAC9E,CAAA"}
+{"version":3,"file":"digitalocean-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/digitalocean-store.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;AAc1B,eAAO,MAAM,IAAI,EAAE,cAUlB,CAAA;AAED,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwB1C,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,wCAAwC,CAAC,KAAK,CACQ,CAAA;AAE/D,eAAO,MACa,wDAAwD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC1D,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEpE,sEAAsE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACvD,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,kCAAkC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AACvE,MAAM,MAAM,kDAAkD,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AAC7F,MAAM,MAAM,gDAAgD,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAClG,MAAM,MAAM,qDAAqD,GAC/D,YAAY,CAAC,qBAAqB,CAAC,CAAA;AACrC,MAAM,MAAM,gEAAgE,GAC1E,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,qEAAqE,GAC/E,YAAY,CAAC,2BAA2B,CAAC,CAAA"}

package/dist/v4/robots/digitalocean-store.js

@@ -1,65 +1,29 @@
 import { z } from 'zod/v4';
-import { digitalOceanBase, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { createStorageStoreExample, defineRobot, digitalOceanBase, robotBase, robotStoreMeta, robotUse, signedSslUrlLifetime, storageAcl, storeFilePath, } from "./_instructions-primitives.js";
 export const meta = {
-    bytescount: 6,
-    discount_factor: 0.15000150001500018,
-    discount_pct: 84.99984999849998,
-    example_code: {
-        steps: {
-            exported: {
-                robot: '/digitalocean/store',
-                use: ':original',
-                credentials: 'YOUR_DIGITALOCEAN_CREDENTIALS',
-                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
-            },
-        },
-    },
+    ...robotStoreMeta,
+    example_code: createStorageStoreExample('/digitalocean/store', 'YOUR_DIGITALOCEAN_CREDENTIALS'),
     example_code_description: 'Export uploaded files to `my_target_folder` on DigitalOcean Spaces:',
     has_small_icon: true,
-    minimum_charge: 0,
-    output_factor: 1,
-    override_lvl1: 'File Exporting',
     purpose_sentence: 'exports encoding results to DigitalOcean Spaces',
-    purpose_verb: 'export',
     purpose_word: 'DigitalOcean Spaces',
     purpose_words: 'Export files to DigitalOcean Spaces',
-    service_slug: 'file-exporting',
-    slot_count: 10,
     title: 'Export files to DigitalOcean Spaces',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'file',
     name: 'DigitalOceanStoreRobot',
-    priceFactor: 6.6666,
-    queueSlotCount: 10,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: false,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotDigitaloceanStoreInstructionsSchema = robotBase
     .merge(robotUse)
     .merge(digitalOceanBase)
     .extend({
     robot: z.literal('/digitalocean/store'),
-    path: z
-        .string()
-        .default('${unique_prefix}/${file.url_name}')
-        .describe(`
-The path at which the file is to be stored. This may include any available [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables). The path must not be a directory.
-`),
+    path: storeFilePath,
     url_prefix: z
         .string()
         .default('https://{space}.{region}.digitaloceanspaces.com/')
         .describe(`
 The URL prefix used for the returned URL, such as \`"https://my.cdn.com/some/path"\`.
 `),
-    acl: z
-        .enum(['private', 'public-read'])
-        .default('public-read')
-        .describe(`
-The permissions used for this file.
-`),
+    acl: storageAcl,
     headers: z.record(z.string(), z.string())
         .default({ 'Content-Type': '${file.mime}' })
         .describe(`
@@ -69,20 +33,8 @@ An object containing a list of headers to be set for this file on DigitalOcean S
 
 Object Metadata can be specified using \`x-amz-meta-*\` headers. Note that these headers [do not support non-ASCII metadata values](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#UserMetadata).
 `),
-    sign_urls_for: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe(`
-This parameter provides signed URLs in the result JSON (in the \`signed_ssl_url\` property). The number that you set this parameter to is the URL expiry time in seconds. If this parameter is not used, no URL signing is done.
-`),
+    sign_urls_for: signedSslUrlLifetime,
 })
     .strict();
-export const robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema = robotDigitaloceanStoreInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotDigitaloceanStoreInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotDigitaloceanStoreInstructionsSchema = interpolateRobot(robotDigitaloceanStoreInstructionsSchema);
-export const interpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotDigitaloceanStoreInstructionsSchema);
+export const { withHiddenFields: robotDigitaloceanStoreInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotDigitaloceanStoreInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotDigitaloceanStoreInstructionsWithHiddenFieldsSchema, } = robotDefinition;