transloadit 3.0.2 → 4.0.0-4

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotCloudflareStoreInstructionsSchema = 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: '/cloudflare/store',
+                use: ':original',
+                credentials: 'YOUR_CLOUDFLARE_CREDENTIALS',
+                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+            },
+        },
+    },
+    example_code_description: 'Export uploaded files to `my_target_folder` on cloudflare R2:',
+    extended_description: `
+The URL to the result file will be returned in the <dfn>Assembly Status JSON</dfn>.
+`,
+    has_small_icon: true,
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Exporting',
+    purpose_sentence: 'exports encoding results to cloudflare r2 buckets',
+    purpose_verb: 'export',
+    purpose_word: 'cloudflare',
+    purpose_words: 'Export files to Cloudflare R2',
+    service_slug: 'file-exporting',
+    slot_count: 10,
+    title: 'Export files to Cloudflare R2',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotCloudflareStoreInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .merge(_instructions_primitives_ts_1.cloudflareBase)
+    .extend({
+    robot: zod_1.z.literal('/cloudflare/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). The path must not be a directory.
+`),
+    headers: zod_1.z.record(zod_1.z.string()).default({ 'Content-Type': '${file.mime}' }).describe(`
+An object containing a list of headers to be set for this file on cloudflare Spaces, such as \`{ FileURL: "\${file.url_name}" }\`. This can also include any available [Assembly Variables](/docs/topics/assembly-instructions/#assembly-variables).
+
+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: zod_1.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.
+`),
+})
+    .strict();
+//# sourceMappingURL=cloudflare-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-store.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/cloudflare-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,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,+DAA+D;IACzF,oBAAoB,EAAE;;CAEvB;IACC,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,mDAAmD;IACrE,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,YAAY;IAC1B,aAAa,EAAE,+BAA+B;IAC9C,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,+BAA+B;IACtC,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;IACE,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,QAAQ,CAAC;;;;CAItF,CAAC;IACE,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;CAE9D,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/digitalocean-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 robotDigitaloceanImportInstructionsSchema: 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>;
+    space: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+}>, {
+    robot: z.ZodLiteral<"/digitalocean/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: "/digitalocean/import";
+    result: boolean;
+    ignore_errors: string[];
+    files_per_page: number;
+    page_number: number;
+    key?: string | undefined;
+    secret?: string | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    credentials?: string | undefined;
+    space?: string | undefined;
+    region?: string | undefined;
+}, {
+    path: string | string[];
+    robot: "/digitalocean/import";
+    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;
+    page_number?: number | undefined;
+    space?: string | undefined;
+    region?: string | undefined;
+}>;
+export type RobotDigitaloceanImportInstructions = z.infer<typeof robotDigitaloceanImportInstructionsSchema>;
+export type RobotDigitaloceanImportInstructionsInput = z.input<typeof robotDigitaloceanImportInstructionsSchema>;
+//# sourceMappingURL=digitalocean-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"digitalocean-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-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,SA8BlB,CAAA;AAED,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B3C,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA;AACD,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,KAAK,CAC5D,OAAO,yCAAyC,CACjD,CAAA"}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotDigitaloceanImportInstructionsSchema = 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: '/digitalocean/import',
+                credentials: 'YOUR_DIGITALOCEAN_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 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',
+};
+exports.robotDigitaloceanImportInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotImport)
+    .merge(_instructions_primitives_ts_1.digitalOceanBase)
+    .extend({
+    robot: zod_1.z.literal('/digitalocean/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: _instructions_primitives_ts_1.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: _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=digitalocean-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"digitalocean-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-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,sBAAsB;gBAC7B,WAAW,EAAE,+BAA+B;gBAC5C,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,6DAA6D;IAC/E,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,qBAAqB;IACnC,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,yCAAyC,GAAG,uCAAS;KAC/D,KAAK,CAAC,yCAAW,CAAC;KAClB,KAAK,CAAC,8CAAgB,CAAC;KACvB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,sBAAsB,CAAC;IACxC,IAAI,EAAE,kCAAI,CAAC,QAAQ,CAAC;;;;;;;;CAQvB,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/digitalocean-store.d.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotDigitaloceanStoreInstructionsSchema: 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>;
+    space: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    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.ZodEnum<["private", "public-read"]>>;
+    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: "/digitalocean/store";
+    result: boolean;
+    url_prefix: string;
+    acl: "private" | "public-read";
+    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;
+    sign_urls_for?: number | undefined;
+    space?: string | undefined;
+    region?: string | undefined;
+}, {
+    robot: "/digitalocean/store";
+    path?: string | undefined;
+    headers?: Record<string, 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;
+    sign_urls_for?: number | undefined;
+    space?: string | undefined;
+    region?: string | undefined;
+    url_prefix?: string | undefined;
+    acl?: "private" | "public-read" | undefined;
+}>;
+export type RobotDigitaloceanStoreInstructions = z.infer<typeof robotDigitaloceanStoreInstructionsSchema>;
+export type RobotDigitaloceanStoreInstructionsInput = z.input<typeof robotDigitaloceanStoreInstructionsSchema>;
+//# sourceMappingURL=digitalocean-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"digitalocean-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-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,SA6BlB,CAAA;AAED,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1C,CAAA;AAEX,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,wCAAwC,CAChD,CAAA"}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotDigitaloceanStoreInstructionsSchema = 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: '/digitalocean/store',
+                use: ':original',
+                credentials: 'YOUR_DIGITALOCEAN_CREDENTIALS',
+                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+            },
+        },
+    },
+    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',
+};
+exports.robotDigitaloceanStoreInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .merge(_instructions_primitives_ts_1.digitalOceanBase)
+    .extend({
+    robot: zod_1.z.literal('/digitalocean/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). The path must not be a directory.
+`),
+    url_prefix: zod_1.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: zod_1.z.enum(['private', 'public-read']).default('public-read').describe(`
+The permissions used for this file.
+`),
+    headers: zod_1.z.record(zod_1.z.string()).default({ 'Content-Type': '${file.mime}' }).describe(`
+An object containing a list of headers to be set for this file on DigitalOcean Spaces, such as \`{ FileURL: "\${file.url_name}" }\`. This can also include any available [Assembly Variables](/docs/topics/assembly-instructions/#assembly-variables).
+
+[Here](https://developers.digitalocean.com/documentation/spaces/#object) you can find a list of available headers.
+
+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: zod_1.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.
+`),
+})
+    .strict();
+//# sourceMappingURL=digitalocean-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"digitalocean-store.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/digitalocean-store.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAqF;AAGxE,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,qBAAqB;gBAC5B,GAAG,EAAE,WAAW;gBAChB,WAAW,EAAE,+BAA+B;gBAC5C,IAAI,EAAE,oDAAoD;aAC3D;SACF;KACF;IACD,wBAAwB,EAAE,qEAAqE;IAC/F,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,iDAAiD;IACnE,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,qBAAqB;IACnC,aAAa,EAAE,qCAAqC;IACpD,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,qCAAqC;IAC5C,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,wCAAwC,GAAG,uCAAS;KAC9D,KAAK,CAAC,sCAAQ,CAAC;KACf,KAAK,CAAC,8CAAgB,CAAC;KACvB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,qBAAqB,CAAC;IACvC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,QAAQ,CAAC;;CAE1E,CAAC;IACE,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,kDAAkD,CAAC,CAAC,QAAQ,CAAC;;CAE/F,CAAC;IACE,GAAG,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC;;CAE3E,CAAC;IACE,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,QAAQ,CAAC;;;;;;CAMtF,CAAC;IACE,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;CAE9D,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/document-autorotate.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotDocumentAutorotateInstructionsSchema: z.ZodObject<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;
+    }>]>>;
+}>, {
+    robot: z.ZodLiteral<"/document/autorotate">;
+}>, "strict", z.ZodTypeAny, {
+    robot: "/document/autorotate";
+    result: boolean;
+    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;
+}, {
+    robot: "/document/autorotate";
+    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;
+}>;
+export type RobotDocumentAutorotateInstructions = z.infer<typeof robotDocumentAutorotateInstructionsSchema>;
+//# sourceMappingURL=document-autorotate.d.ts.map

package/dist/alphalib/types/robots/document-autorotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-autorotate.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/document-autorotate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAG9D,eAAO,MAAM,IAAI,EAAE,SAmBlB,CAAA;AAED,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK3C,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA"}

package/dist/alphalib/types/robots/document-autorotate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotDocumentAutorotateInstructionsSchema = 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: 1,
+    discount_factor: 1,
+    discount_pct: 0,
+    example_code_description: 'Auto-rotate individual pages of a documents to the correction orientation:',
+    minimum_charge: 2097152,
+    output_factor: 1,
+    override_lvl1: 'Document Processing',
+    purpose_sentence: 'corrects the orientation of documents',
+    purpose_verb: 'auto-rotate',
+    purpose_word: 'auto-rotate documents',
+    purpose_words: 'Auto-rotate documents',
+    service_slug: 'document-processing',
+    slot_count: 10,
+    title: 'Auto-rotate documents to the correct orientation',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'document',
+};
+exports.robotDocumentAutorotateInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .extend({
+    robot: zod_1.z.literal('/document/autorotate'),
+})
+    .strict();
+//# sourceMappingURL=document-autorotate.js.map

package/dist/alphalib/types/robots/document-autorotate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-autorotate.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/document-autorotate.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAGvB,+EAAmE;AAEtD,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,wBAAwB,EACtB,4EAA4E;IAC9E,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,qBAAqB;IACpC,gBAAgB,EAAE,uCAAuC;IACzD,YAAY,EAAE,aAAa;IAC3B,YAAY,EAAE,uBAAuB;IACrC,aAAa,EAAE,uBAAuB;IACtC,YAAY,EAAE,qBAAqB;IACnC,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,kDAAkD;IACzD,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,UAAU;CAC9B,CAAA;AAEY,QAAA,yCAAyC,GAAG,uCAAS;KAC/D,KAAK,CAAC,sCAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,sBAAsB,CAAC;CACzC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/document-convert.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotDocumentConvertInstructionsSchema: z.ZodObject<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;
+    }>]>>;
+}>, {
+    robot: z.ZodLiteral<"/document/convert">;
+    format: z.ZodEnum<["ai", "csv", "doc", "docx", "eps", "gif", "html", "jpeg", "jpg", "latex", "oda", "odd", "odt", "ott", "pdf", "png", "pot", "pps", "ppt", "pptx", "ppz", "ps", "rtf", "rtx", "srt", "svg", "text", "txt", "vtt", "xhtml", "xla", "xls", "xlsx", "xml"]>;
+    markdown_format: z.ZodDefault<z.ZodEnum<["commonmark", "gfm"]>>;
+    markdown_theme: z.ZodDefault<z.ZodEnum<["bare", "github"]>>;
+    pdf_margin: z.ZodDefault<z.ZodString>;
+    pdf_print_background: z.ZodDefault<z.ZodBoolean>;
+    pdf_format: z.ZodDefault<z.ZodEnum<["A0", "A1", "A2", "A3", "A4", "A5", "A6", "Ledger", "Legal", "Letter", "Tabloid"]>>;
+    pdf_display_header_footer: z.ZodDefault<z.ZodBoolean>;
+    pdf_header_template: z.ZodOptional<z.ZodString>;
+    pdf_footer_template: z.ZodOptional<z.ZodString>;
+}>, "strict", z.ZodTypeAny, {
+    format: "text" | "gif" | "ai" | "csv" | "doc" | "docx" | "eps" | "html" | "jpeg" | "jpg" | "latex" | "oda" | "odd" | "odt" | "ott" | "pdf" | "png" | "pot" | "pps" | "ppt" | "pptx" | "ppz" | "ps" | "rtf" | "rtx" | "srt" | "svg" | "txt" | "vtt" | "xhtml" | "xla" | "xls" | "xlsx" | "xml";
+    robot: "/document/convert";
+    result: boolean;
+    markdown_format: "commonmark" | "gfm";
+    markdown_theme: "bare" | "github";
+    pdf_margin: string;
+    pdf_print_background: boolean;
+    pdf_format: "A0" | "A1" | "A2" | "A3" | "A4" | "A5" | "A6" | "Ledger" | "Legal" | "Letter" | "Tabloid";
+    pdf_display_header_footer: boolean;
+    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;
+    pdf_header_template?: string | undefined;
+    pdf_footer_template?: string | undefined;
+}, {
+    format: "text" | "gif" | "ai" | "csv" | "doc" | "docx" | "eps" | "html" | "jpeg" | "jpg" | "latex" | "oda" | "odd" | "odt" | "ott" | "pdf" | "png" | "pot" | "pps" | "ppt" | "pptx" | "ppz" | "ps" | "rtf" | "rtx" | "srt" | "svg" | "txt" | "vtt" | "xhtml" | "xla" | "xls" | "xlsx" | "xml";
+    robot: "/document/convert";
+    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;
+    markdown_format?: "commonmark" | "gfm" | undefined;
+    markdown_theme?: "bare" | "github" | undefined;
+    pdf_margin?: string | undefined;
+    pdf_print_background?: boolean | undefined;
+    pdf_format?: "A0" | "A1" | "A2" | "A3" | "A4" | "A5" | "A6" | "Ledger" | "Legal" | "Letter" | "Tabloid" | undefined;
+    pdf_display_header_footer?: boolean | undefined;
+    pdf_header_template?: string | undefined;
+    pdf_footer_template?: string | undefined;
+}>;
+export type RobotDocumentConvertInstructions = z.infer<typeof robotDocumentConvertInstructionsSchema>;
+//# sourceMappingURL=document-convert.d.ts.map

package/dist/alphalib/types/robots/document-convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-convert.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/document-convert.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,SAsElB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwGxC,CAAA;AAEX,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA"}