transloadit 3.0.2 → 4.0.0-2

package/dist/alphalib/types/robots/backblaze-store.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotBackblazeStoreInstructionsSchema = exports.meta = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.meta = {
+    allowed_for_url_transform: true,
+    bytescount: 6,
+    discount_factor: 0.15000150001500018,
+    discount_pct: 84.99984999849998,
+    example_code: {
+        steps: {
+            exported: {
+                robot: '/backblaze/store',
+                use: ':original',
+                credentials: 'YOUR_BACKBLAZE_CREDENTIALS',
+                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+            },
+        },
+    },
+    example_code_description: 'Export uploaded files to `my_target_folder` on Backblaze:',
+    extended_description: `
+## Access
+
+Your Backblaze buckets need to have the \`listBuckets\` (to obtain a bucket ID from a bucket name), \`writeFiles\` and \`listFiles\` permissions.
+`,
+    has_small_icon: true,
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Exporting',
+    purpose_sentence: 'exports encoding results to Backblaze',
+    purpose_verb: 'export',
+    purpose_word: 'Backblaze',
+    purpose_words: 'Export files to Backblaze',
+    service_slug: 'file-exporting',
+    slot_count: 10,
+    title: 'Export files to Backblaze',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotBackblazeStoreInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .merge(_instructions_primitives_ts_1.backblazeBase)
+    .extend({
+    robot: zod_1.z.literal('/backblaze/store'),
+    path: zod_1.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).
+`),
+    headers: zod_1.z.record(zod_1.z.string()).default({}).describe(`
+An object containing a list of headers to be set for this file on backblaze, such as \`{ FileURL: "\${file.url_name}" }\`. This can also include any available [Assembly Variables](/docs/topics/assembly-instructions/#assembly-variables).
+
+[Here](https://www.backblaze.com/b2/docs/b2_upload_file.html) you can find a list of available headers.
+
+Object Metadata can be specified using \`X-Bz-Info-*\` headers.
+`),
+})
+    .strict();
+//# sourceMappingURL=backblaze-store.js.map

package/dist/alphalib/types/robots/backblaze-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backblaze-store.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/backblaze-store.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAkF;AAGrE,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,mBAAmB;IACpC,YAAY,EAAE,iBAAiB;IAC/B,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,kBAAkB;gBACzB,GAAG,EAAE,WAAW;gBAChB,WAAW,EAAE,4BAA4B;gBACzC,IAAI,EAAE,oDAAoD;aAC3D;SACF;KACF;IACD,wBAAwB,EAAE,2DAA2D;IACrF,oBAAoB,EAAE;;;;CAIvB;IACC,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,uCAAuC;IACzD,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,WAAW;IACzB,aAAa,EAAE,2BAA2B;IAC1C,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,2BAA2B;IAClC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,qCAAqC,GAAG,uCAAS;KAC3D,KAAK,CAAC,sCAAQ,CAAC;KACf,KAAK,CAAC,2CAAa,CAAC;KACpB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACpC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,QAAQ,CAAC;;CAE1E,CAAC;IACE,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC;;;;;;CAMtD,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

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

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotCloudfilesImportInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import"]>, "many">]>, string[], boolean | ("meta" | "import")[]>>;
+}>, {
+    credentials: z.ZodOptional<z.ZodString>;
+    account_type: z.ZodOptional<z.ZodEnum<["uk", "us"]>>;
+    data_center: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    container: z.ZodOptional<z.ZodString>;
+}>, {
+    robot: z.ZodLiteral<"/cloudfiles/import">;
+    path: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    page_number: z.ZodDefault<z.ZodNumber>;
+    files_per_page: z.ZodDefault<z.ZodNumber>;
+}>, "strict", z.ZodTypeAny, {
+    path: string | string[];
+    recursive: boolean;
+    robot: "/cloudfiles/import";
+    result: boolean;
+    ignore_errors: string[];
+    files_per_page: number;
+    page_number: number;
+    key?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    credentials?: string | undefined;
+    container?: string | undefined;
+    account_type?: "uk" | "us" | undefined;
+    data_center?: string | undefined;
+    user?: string | undefined;
+}, {
+    path: string | string[];
+    robot: "/cloudfiles/import";
+    key?: string | undefined;
+    recursive?: boolean | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    ignore_errors?: boolean | ("meta" | "import")[] | undefined;
+    credentials?: string | undefined;
+    container?: string | undefined;
+    files_per_page?: number | undefined;
+    account_type?: "uk" | "us" | undefined;
+    data_center?: string | undefined;
+    user?: string | undefined;
+    page_number?: number | undefined;
+}>;
+export type RobotCloudfilesImportInstructions = z.infer<typeof robotCloudfilesImportInstructionsSchema>;
+export type RobotCloudfilesImportInstructionsInput = z.input<typeof robotCloudfilesImportInstructionsSchema>;
+//# sourceMappingURL=cloudfiles-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudfiles-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudfiles-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SA8BlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BzC,CAAA;AAEX,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,uCAAuC,CAC/C,CAAA"}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotCloudfilesImportInstructionsSchema = exports.meta = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.meta = {
+    allowed_for_url_transform: true,
+    bytescount: 10,
+    discount_factor: 0.1,
+    discount_pct: 90,
+    example_code: {
+        steps: {
+            imported: {
+                robot: '/cloudfiles/import',
+                credentials: 'YOUR_CLOUDFILES_CREDENTIALS',
+                path: 'path/to/files/',
+                recursive: true,
+            },
+        },
+    },
+    example_code_description: 'Import files from the `path/to/files` directory and its subdirectories:',
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Importing',
+    purpose_sentence: 'imports whole directories of files from your Rackspace Cloud Files container',
+    purpose_verb: 'import',
+    purpose_word: 'Rackspace Cloud Files',
+    purpose_words: 'Import files from Rackspace Cloud Files',
+    requires_credentials: true,
+    service_slug: 'file-importing',
+    slot_count: 20,
+    title: 'Import files from Rackspace Cloud Files',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotCloudfilesImportInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotImport)
+    .merge(_instructions_primitives_ts_1.cloudfilesBase)
+    .extend({
+    robot: zod_1.z.literal('/cloudfiles/import'),
+    path: _instructions_primitives_ts_1.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.
+
+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: zod_1.z.boolean().default(false).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: _instructions_primitives_ts_1.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: _instructions_primitives_ts_1.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.
+`),
+})
+    .strict();
+//# sourceMappingURL=cloudfiles-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudfiles-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudfiles-import.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAOsC;AAGzB,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,EAAE;IACd,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,EAAE;IAChB,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,oBAAoB;gBAC3B,WAAW,EAAE,6BAA6B;gBAC1C,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,IAAI;aAChB;SACF;KACF;IACD,wBAAwB,EACtB,yEAAyE;IAC3E,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,8EAA8E;IAChG,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,uBAAuB;IACrC,aAAa,EAAE,yCAAyC;IACxD,oBAAoB,EAAE,IAAI;IAC1B,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,yCAAyC;IAChD,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,uCAAuC,GAAG,uCAAS;KAC7D,KAAK,CAAC,yCAAW,CAAC;KAClB,KAAK,CAAC,4CAAc,CAAC;KACrB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IACtC,IAAI,EAAE,kCAAI,CAAC,QAAQ,CAAC;;;;;;;;CAQvB,CAAC;IACE,SAAS,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;;;CAIlD,CAAC;IACE,WAAW,EAAE,yCAAW,CAAC,QAAQ,CAAC;;;;CAIrC,CAAC;IACE,cAAc,EAAE,4CAAc,CAAC,QAAQ,CAAC;;CAE3C,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/cloudfiles-store.d.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotCloudfilesStoreInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+}>, {
+    credentials: z.ZodOptional<z.ZodString>;
+    account_type: z.ZodOptional<z.ZodEnum<["uk", "us"]>>;
+    data_center: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    container: z.ZodOptional<z.ZodString>;
+}>, {
+    robot: z.ZodLiteral<"/cloudfiles/store">;
+    path: z.ZodDefault<z.ZodString>;
+}>, "strict", z.ZodTypeAny, {
+    path: string;
+    robot: "/cloudfiles/store";
+    result: boolean;
+    key?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    credentials?: string | undefined;
+    container?: string | undefined;
+    account_type?: "uk" | "us" | undefined;
+    data_center?: string | undefined;
+    user?: string | undefined;
+}, {
+    robot: "/cloudfiles/store";
+    path?: string | undefined;
+    key?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    credentials?: string | undefined;
+    container?: string | undefined;
+    account_type?: "uk" | "us" | undefined;
+    data_center?: string | undefined;
+    user?: string | undefined;
+}>;
+export type RobotCloudfilesStoreInstructions = z.infer<typeof robotCloudfilesStoreInstructionsSchema>;
+export type RobotCloudfilesStoreInstructionsInput = z.input<typeof robotCloudfilesStoreInstructionsSchema>;
+//# sourceMappingURL=cloudfiles-store.d.ts.map

package/dist/alphalib/types/robots/cloudfiles-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudfiles-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudfiles-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SAuClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxC,CAAA;AAEX,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,sCAAsC,CAC9C,CAAA"}

package/dist/alphalib/types/robots/cloudfiles-store.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotCloudfilesStoreInstructionsSchema = exports.meta = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.meta = {
+    allowed_for_url_transform: true,
+    bytescount: 6,
+    discount_factor: 0.15000150001500018,
+    discount_pct: 84.99984999849998,
+    docs_redirect_from: ['/docs/export-to-rackspace-cloudfiles/'],
+    example_code: {
+        steps: {
+            exported: {
+                robot: '/cloudfiles/store',
+                use: ':original',
+                credentials: 'YOUR_CLOUDFILES_CREDENTIALS',
+                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+            },
+        },
+    },
+    example_code_description: 'Export uploaded files to `my_target_folder` on Rackspace Cloud Files:',
+    extended_description: `
+<a id="export-to-rackspace-cloudfiles" aria-hidden="true"></a>
+
+## A note about URLs
+
+If your container is CDN-enabled, the resulting \`file.url\` indicates the path to the file in your
+CDN container, or is \`null\` otherwise.
+
+The storage container URL for this file is always available via \`file.meta.storage_url\`.
+`,
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Exporting',
+    purpose_sentence: 'exports encoding results to Rackspace Cloud Files',
+    purpose_verb: 'export',
+    purpose_word: 'Rackspace Cloud Files',
+    purpose_words: 'Export files to Rackspace Cloud Files',
+    service_slug: 'file-exporting',
+    slot_count: 10,
+    title: 'Export files to Rackspace Cloud Files',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotCloudfilesStoreInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .merge(_instructions_primitives_ts_1.cloudfilesBase)
+    .extend({
+    robot: zod_1.z.literal('/cloudfiles/store'),
+    path: zod_1.z.string().default('${unique_prefix}/${file.url_name}').describe(`
+The path at which to store the file. This value can also contain [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables).
+`),
+})
+    .strict();
+//# sourceMappingURL=cloudfiles-store.js.map

package/dist/alphalib/types/robots/cloudfiles-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudfiles-store.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudfiles-store.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAmF;AAGtE,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,mBAAmB;IACpC,YAAY,EAAE,iBAAiB;IAC/B,kBAAkB,EAAE,CAAC,uCAAuC,CAAC;IAC7D,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,mBAAmB;gBAC1B,GAAG,EAAE,WAAW;gBAChB,WAAW,EAAE,6BAA6B;gBAC1C,IAAI,EAAE,oDAAoD;aAC3D;SACF;KACF;IACD,wBAAwB,EAAE,uEAAuE;IACjG,oBAAoB,EAAE;;;;;;;;;CASvB;IACC,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,mDAAmD;IACrE,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,uBAAuB;IACrC,aAAa,EAAE,uCAAuC;IACtD,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,uCAAuC;IAC9C,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,sCAAsC,GAAG,uCAAS;KAC5D,KAAK,CAAC,sCAAQ,CAAC;KACf,KAAK,CAAC,4CAAc,CAAC;KACrB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;IACrC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,QAAQ,CAAC;;CAE1E,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotCloudflareImportInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import"]>, "many">]>, string[], boolean | ("meta" | "import")[]>>;
+}>, {
+    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<"/cloudflare/import">;
+    path: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    page_number: z.ZodDefault<z.ZodNumber>;
+    files_per_page: z.ZodDefault<z.ZodNumber>;
+}>, "strict", z.ZodTypeAny, {
+    path: string | string[];
+    recursive: boolean;
+    robot: "/cloudflare/import";
+    result: boolean;
+    ignore_errors: string[];
+    files_per_page: number;
+    page_number: number;
+    host?: string | undefined;
+    key?: string | undefined;
+    secret?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    credentials?: string | undefined;
+    bucket?: string | undefined;
+}, {
+    path: string | string[];
+    robot: "/cloudflare/import";
+    host?: string | undefined;
+    key?: string | undefined;
+    secret?: string | undefined;
+    recursive?: boolean | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    ignore_errors?: boolean | ("meta" | "import")[] | undefined;
+    credentials?: string | undefined;
+    files_per_page?: number | undefined;
+    bucket?: string | undefined;
+    page_number?: number | undefined;
+}>;
+export type RobotCloudflareImportInstructions = z.infer<typeof robotCloudflareImportInstructionsSchema>;
+export type RobotCloudflareImportInstructionsInput = z.input<typeof robotCloudflareImportInstructionsSchema>;
+//# sourceMappingURL=cloudflare-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudflare-import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SA+BlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BzC,CAAA;AAEX,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,uCAAuC,CAC/C,CAAA"}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotCloudflareImportInstructionsSchema = exports.meta = void 0;
+const zod_1 = require("zod");
+const _instructions_primitives_ts_1 = require("./_instructions-primitives.js");
+exports.meta = {
+    allowed_for_url_transform: true,
+    bytescount: 10,
+    discount_factor: 0.1,
+    discount_pct: 90,
+    example_code: {
+        steps: {
+            imported: {
+                robot: '/cloudflare/import',
+                credentials: 'YOUR_CLOUDFLARE_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 cloudflare r2 bucket',
+    purpose_verb: 'import',
+    purpose_word: 'cloudflare',
+    purpose_words: 'Import files from Cloudflare R2',
+    requires_credentials: true,
+    service_slug: 'file-importing',
+    slot_count: 20,
+    title: 'Import files from Cloudflare R2',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotCloudflareImportInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotImport)
+    .merge(_instructions_primitives_ts_1.cloudflareBase)
+    .extend({
+    robot: zod_1.z.literal('/cloudflare/import'),
+    path: _instructions_primitives_ts_1.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: _instructions_primitives_ts_1.recursive.describe(`
+Setting this to \`true\` will enable importing files from subfolders and sub-subfolders, etc. of the given path.
+
+Please use the pagination parameters \`page_number\` and \`files_per_page\` wisely here.
+`),
+    page_number: _instructions_primitives_ts_1.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: _instructions_primitives_ts_1.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.
+`),
+})
+    .strict();
+//# sourceMappingURL=cloudflare-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudflare-import.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAQsC;AAGzB,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,EAAE;IACd,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,EAAE;IAChB,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,oBAAoB;gBAC3B,WAAW,EAAE,6BAA6B;gBAC1C,IAAI,EAAE,gBAAgB;gBACtB,SAAS,EAAE,IAAI;aAChB;SACF;KACF;IACD,wBAAwB,EACtB,yEAAyE;IAC3E,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,mEAAmE;IACrF,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,YAAY;IAC1B,aAAa,EAAE,iCAAiC;IAChD,oBAAoB,EAAE,IAAI;IAC1B,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,iCAAiC;IACxC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,uCAAuC,GAAG,uCAAS;KAC7D,KAAK,CAAC,yCAAW,CAAC;KAClB,KAAK,CAAC,4CAAc,CAAC;KACrB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IACtC,IAAI,EAAE,kCAAI,CAAC,QAAQ,CAAC;;;;;;;;;;CAUvB,CAAC;IACE,SAAS,EAAE,uCAAS,CAAC,QAAQ,CAAC;;;;CAIjC,CAAC;IACE,WAAW,EAAE,yCAAW,CAAC,QAAQ,CAAC;;;;CAIrC,CAAC;IACE,cAAc,EAAE,4CAAc,CAAC,QAAQ,CAAC;;CAE3C,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/cloudflare-store.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotCloudflareStoreInstructionsSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+}, {
+    use: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }, {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }>, "many">]>, z.ZodObject<{
+        steps: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }, {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }>, "many">]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }, {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    }>]>>;
+}>, {
+    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<"/cloudflare/store">;
+    path: z.ZodDefault<z.ZodString>;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    sign_urls_for: z.ZodOptional<z.ZodNumber>;
+}>, "strict", z.ZodTypeAny, {
+    path: string;
+    headers: Record<string, string>;
+    robot: "/cloudflare/store";
+    result: boolean;
+    host?: string | undefined;
+    key?: string | undefined;
+    secret?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    credentials?: string | undefined;
+    bucket?: string | undefined;
+    sign_urls_for?: number | undefined;
+}, {
+    robot: "/cloudflare/store";
+    path?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    host?: string | undefined;
+    key?: string | undefined;
+    secret?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    use?: string | string[] | {
+        name: string;
+        fields?: string | undefined;
+        as?: string | undefined;
+    }[] | {
+        steps: string | string[] | {
+            name: string;
+            fields?: string | undefined;
+            as?: string | undefined;
+        }[];
+        bundle_steps?: boolean | undefined;
+        group_by_original?: boolean | undefined;
+    } | undefined;
+    credentials?: string | undefined;
+    bucket?: string | undefined;
+    sign_urls_for?: number | undefined;
+}>;
+export type RobotCloudflareStoreInstructions = z.infer<typeof robotCloudflareStoreInstructionsSchema>;
+export type RobotCloudflareStoreInstructionsInput = z.input<typeof robotCloudflareStoreInstructionsSchema>;
+//# sourceMappingURL=cloudflare-store.d.ts.map

package/dist/alphalib/types/robots/cloudflare-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudflare-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SAgClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBxC,CAAA;AAEX,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,sCAAsC,CAC9C,CAAA"}