transloadit 3.0.2 → 4.0.0-2

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotGoogleImportInstructionsSchema = 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: '/google/import',
+                credentials: 'YOUR_GOOGLE_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 Google Storage',
+    purpose_verb: 'import',
+    purpose_word: 'Google Storage',
+    purpose_words: 'Import files from Google Storage',
+    service_slug: 'file-importing',
+    slot_count: 20,
+    title: 'Import files from Google Storage',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotGoogleImportInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotImport)
+    .merge(_instructions_primitives_ts_1.googleBase)
+    .extend({
+    robot: zod_1.z.literal('/google/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 a 404 \`GOOGLE_IMPORT_NOT_FOUND\` error.
+
+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 \`start_file_name\` and \`files_per_page\` wisely here.
+`),
+    next_page_token: _instructions_primitives_ts_1.next_page_token.describe(`
+A string token used for pagination. The returned files of one paginated call have the next page token inside of their meta data, which needs to be used for the subsequent paging call.
+`),
+    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=google-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"google-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-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,gBAAgB;gBACvB,WAAW,EAAE,yBAAyB;gBACtC,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,wDAAwD;IAC1E,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,gBAAgB;IAC9B,aAAa,EAAE,kCAAkC;IACjD,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,kCAAkC;IACzC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,mCAAmC,GAAG,uCAAS;KACzD,KAAK,CAAC,yCAAW,CAAC;KAClB,KAAK,CAAC,wCAAU,CAAC;KACjB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;IAClC,IAAI,EAAE,kCAAI,CAAC,QAAQ,CAAC;;;;;;;;;;CAUvB,CAAC;IACE,SAAS,EAAE,uCAAS,CAAC,QAAQ,CAAC;;;;CAIjC,CAAC;IACE,eAAe,EAAE,6CAAe,CAAC,QAAQ,CAAC;;CAE7C,CAAC;IACE,cAAc,EAAE,4CAAc,CAAC,QAAQ,CAAC;;CAE3C,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

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

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotGoogleStoreInstructionsSchema: 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>;
+}>, {
+    robot: z.ZodLiteral<"/google/store">;
+    result: z.ZodOptional<z.ZodBoolean>;
+    credentials: z.ZodString;
+    path: z.ZodDefault<z.ZodString>;
+    acl: z.ZodDefault<z.ZodNullable<z.ZodEnum<["authenticated-read", "bucket-owner-full-control", "private", "project-private", "public-read"]>>>;
+    cache_control: z.ZodOptional<z.ZodString>;
+    url_template: z.ZodDefault<z.ZodString>;
+    ssl_url_template: z.ZodDefault<z.ZodString>;
+}>, "strict", z.ZodTypeAny, {
+    path: string;
+    robot: "/google/store";
+    credentials: string;
+    acl: "private" | "public-read" | "authenticated-read" | "bucket-owner-full-control" | "project-private" | null;
+    url_template: string;
+    ssl_url_template: string;
+    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;
+    cache_control?: string | undefined;
+}, {
+    robot: "/google/store";
+    credentials: string;
+    path?: 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;
+    cache_control?: string | undefined;
+    acl?: "private" | "public-read" | "authenticated-read" | "bucket-owner-full-control" | "project-private" | null | undefined;
+    url_template?: string | undefined;
+    ssl_url_template?: string | undefined;
+}>;
+export type RobotGoogleStoreInstructions = z.infer<typeof robotGoogleStoreInstructionsSchema>;
+export type RobotGoogleStoreInstructionsInput = z.input<typeof robotGoogleStoreInstructionsSchema>;
+//# sourceMappingURL=google-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"google-store.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-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,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDpC,CAAA;AAEX,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA"}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotGoogleStoreInstructionsSchema = 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: '/google/store',
+                use: ':original',
+                credentials: 'YOUR_GOOGLE_CREDENTIALS',
+                path: 'my_target_folder/${unique_prefix}/${file.url_name}',
+            },
+        },
+    },
+    example_code_description: 'Export uploaded files to `my_target_folder` on Google Storage:',
+    has_small_icon: true,
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Exporting',
+    purpose_sentence: 'exports encoding results to Google Storage',
+    purpose_verb: 'export',
+    purpose_word: 'Google Storage',
+    purpose_words: 'Export files to Google Storage',
+    service_slug: 'file-exporting',
+    slot_count: 10,
+    title: 'Export files to Google Storage',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotGoogleStoreInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .merge(_instructions_primitives_ts_1.googleBase)
+    .extend({
+    robot: zod_1.z.literal('/google/store').describe(`
+The URL to the exported file in your Google bucket will be presented in the Transloadit <dfn>Assembly Status</dfn> JSON. This <dfn>Robot</dfn> can also be used to export encoded files to Google's Firebase as demonstrated in [this blogpost](/blog/2018/12/2h-youtube-clone/).
+`),
+    result: zod_1.z
+        .boolean()
+        .optional()
+        .describe(`Whether the results of this Step should be present in the Assembly Status JSON`),
+    credentials: zod_1.z.string().describe(`
+Create a new [Google service account](https://cloud.google.com/storage/docs/authentication). Set its role to "Storage Object Creator". Choose "JSON" for the key file format and download it to your computer. You will need to upload this file when creating your <dfn>Template Credentials</dfn>.
+
+Go back to your Google credentials project and enable the "Google Cloud Storage JSON API" for it. Wait around ten minutes for the action to propagate through the Google network. Grab the project ID from the dropdown menu in the header bar on the Google site. You will also need it later on.
+
+Now you can set up the \`storage.objects.create\` and \`storage.objects.delete\` permissions. The latter is optional and only required if you intend to overwrite existing paths.
+
+To do this from the Google Cloud console, navigate to "IAM &amp; Admin" and select "Roles". From here, select "+CREATE ROLE", enter a name, set the role launch stage as general availability and set the permissions stated above.
+
+Next, relocate to your storage browser and select the ellipsis on your bucket to edit bucket permissions. From here, select "ADD MEMBER", enter your service account as a new member and select your newly created role.
+
+Then, create your associated [Template Credentials](/c/template-credentials/) in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value.
+`),
+    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).
+`),
+    acl: zod_1.z
+        .enum([
+        'authenticated-read',
+        'bucket-owner-full-control',
+        'private',
+        'project-private',
+        'public-read',
+    ])
+        .nullable()
+        .default('public-read').describe(`
+The permissions used for this file.
+`),
+    cache_control: zod_1.z.string().optional().describe(`
+The \`Cache-Control\` header determines how long browsers are allowed to cache your object for. Values specified with this parameter will be added to the object's metadata under the \`Cache-Control\` header. For more information on valid values, take a look at the [official Google documentation](https://cloud.google.com/storage/docs/metadata#cache-control).
+`),
+    url_template: zod_1.z.string().default('https://{HOST}/{PATH}').describe(`
+The URL of the file in the result JSON. This may include any of the following supported [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables).
+`),
+    ssl_url_template: zod_1.z.string().default('https://{HOST}/{PATH}').describe(`
+The SSL URL of the file in the result JSON. The following [Assembly variables](/docs/topics/assembly-instructions/#assembly-variables) are supported.
+`),
+})
+    .strict();
+//# sourceMappingURL=google-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"google-store.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/google-store.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAA+E;AAGlE,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,eAAe;gBACtB,GAAG,EAAE,WAAW;gBAChB,WAAW,EAAE,yBAAyB;gBACtC,IAAI,EAAE,oDAAoD;aAC3D;SACF;KACF;IACD,wBAAwB,EAAE,gEAAgE;IAC1F,cAAc,EAAE,IAAI;IACpB,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,4CAA4C;IAC9D,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,gBAAgB;IAC9B,aAAa,EAAE,gCAAgC;IAC/C,YAAY,EAAE,gBAAgB;IAC9B,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,gCAAgC;IACvC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,MAAM;CAC1B,CAAA;AAEY,QAAA,kCAAkC,GAAG,uCAAS;KACxD,KAAK,CAAC,sCAAQ,CAAC;KACf,KAAK,CAAC,wCAAU,CAAC;KACjB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC;;CAE9C,CAAC;IACE,MAAM,EAAE,OAAC;SACN,OAAO,EAAE;SACT,QAAQ,EAAE;SACV,QAAQ,CAAC,gFAAgF,CAAC;IAC7F,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC;;;;;;;;;;;;CAYpC,CAAC;IACE,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,QAAQ,CAAC;;CAE1E,CAAC;IACE,GAAG,EAAE,OAAC;SACH,IAAI,CAAC;QACJ,oBAAoB;QACpB,2BAA2B;QAC3B,SAAS;QACT,iBAAiB;QACjB,aAAa;KACd,CAAC;SACD,QAAQ,EAAE;SACV,OAAO,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC;;CAEtC,CAAC;IACE,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;CAEjD,CAAC;IACE,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC;;CAEtE,CAAC;IACE,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC;;CAE1E,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

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

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotHtmlConvertInstructionsSchema: 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<"/html/convert">;
+    url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    format: z.ZodDefault<z.ZodEnum<["jpeg", "jpg", "pdf", "png"]>>;
+    fullpage: z.ZodDefault<z.ZodBoolean>;
+    omit_background: z.ZodDefault<z.ZodBoolean>;
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    delay: z.ZodDefault<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}>, "strict", z.ZodTypeAny, {
+    format: "jpeg" | "jpg" | "pdf" | "png";
+    url: string | null;
+    robot: "/html/convert";
+    result: boolean;
+    width: number;
+    delay: number;
+    fullpage: boolean;
+    omit_background: boolean;
+    headers?: Record<string, 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;
+    height?: number | undefined;
+}, {
+    robot: "/html/convert";
+    headers?: Record<string, string> | undefined;
+    format?: "jpeg" | "jpg" | "pdf" | "png" | undefined;
+    url?: string | null | 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;
+    width?: number | undefined;
+    height?: number | undefined;
+    delay?: number | undefined;
+    fullpage?: boolean | undefined;
+    omit_background?: boolean | undefined;
+}>;
+export type RobotHtmlConvertInstructions = z.infer<typeof robotHtmlConvertInstructionsSchema>;
+//# sourceMappingURL=html-convert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"html-convert.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/html-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,SAgClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCpC,CAAA;AAEX,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA"}

package/dist/alphalib/types/robots/html-convert.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotHtmlConvertInstructionsSchema = 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,
+    docs_redirect_from: ['/docs/taking-screenshots-of-websites/'],
+    example_code: {
+        steps: {
+            captured: {
+                robot: '/html/convert',
+                url: 'https://transloadit.com',
+            },
+        },
+    },
+    example_code_description: 'Take a full screenshot of the Transloadit homepage:',
+    extended_description: `
+**Warning:** A validation error will occur if neither an HTML file is uploaded nor a URL parameter is given. [{.alert .alert-warning}]
+
+**Note:** Any files imported within the HTML page will be included in the cost. [{.alert .alert-note}]
+`,
+    minimum_charge: 1048576,
+    output_factor: 0.5,
+    override_lvl1: 'Document Processing',
+    purpose_sentence: 'takes screenshots of web pages or uploaded HTML pages',
+    purpose_verb: 'take',
+    purpose_word: 'take screenshots of a webpage',
+    purpose_words: 'Take screenshots of webpages or HTML files',
+    service_slug: 'document-processing',
+    slot_count: 10,
+    title: 'Take screenshots of webpages or uploaded HTML files',
+    typical_file_size_mb: 0.6,
+    typical_file_type: 'webpage',
+};
+exports.robotHtmlConvertInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .extend({
+    robot: zod_1.z.literal('/html/convert').describe(`
+A URL can be provided instead of an input HTML file, to capture a screenshot from the website referenced by the URL.
+
+Use [🤖/image/resize](/docs/transcoding/image-manipulation/image-resize/) to resize or crop the screenshot as needed.
+`),
+    url: zod_1.z.string().nullable().default(null).describe(`
+The URL of the web page to be converted. Optional, as you can also upload/import HTML files and pass it to this <dfn>Robot</dfn>.
+`),
+    format: zod_1.z.enum(['jpeg', 'jpg', 'pdf', 'png']).default('png').describe(`
+The format of the resulting image.
+`),
+    fullpage: zod_1.z.boolean().default(true).describe(`
+Determines if a screenshot of the full page should be taken or not.
+
+If set to \`true\`, the \`height\` parameter will not have any effect, as heights of websites vary. You can control the size of the resulting image somewhat, though, by setting the \`width\` parameter.
+
+If set to \`false\`, an image will be cropped from the top of the webpage according to your \`width\` and \`height\` parameters.
+`),
+    omit_background: zod_1.z.boolean().default(false).describe(`
+Determines whether to preserve a transparent background in HTML pages. Useful if you're generating artwork in HTML that you want to overlay on e.g. a video.
+
+The default of \`false\` fills transparent areas with a white background, for easier reading/printing.
+
+This parameter is only used when \`format\` is not \`pdf\`.
+`),
+    width: zod_1.z.number().int().min(1).default(1024).describe(`
+The screen width that will be used, in pixels. Change this to change the  dimensions of the resulting image.
+`),
+    height: zod_1.z.number().int().min(1).optional().describe(`
+The screen height that will be used, in pixels. By default this equals the length of the web page in pixels if \`fullpage\` is set to \`true\`. If \`fullpage\` is set to \`false\`, the height parameter takes effect and defaults to the value \`768\`.
+`),
+    delay: zod_1.z.number().int().min(0).default(0).describe(`
+The delay (in milliseconds) applied to allow the page and all of its JavaScript to render before taking the screenshot.
+`),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe(`
+An object containing optional headers that will be passed along with the original request to the website. For example, this parameter can be used to pass along an authorization token along with the request.
+`),
+})
+    .strict();
+//# sourceMappingURL=html-convert.js.map

package/dist/alphalib/types/robots/html-convert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-convert.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/html-convert.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAmE;AAGtD,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,kBAAkB,EAAE,CAAC,uCAAuC,CAAC;IAC7D,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,eAAe;gBACtB,GAAG,EAAE,yBAAyB;aAC/B;SACF;KACF;IACD,wBAAwB,EAAE,qDAAqD;IAC/E,oBAAoB,EAAE;;;;CAIvB;IACC,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,GAAG;IAClB,aAAa,EAAE,qBAAqB;IACpC,gBAAgB,EAAE,uDAAuD;IACzE,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,+BAA+B;IAC7C,aAAa,EAAE,4CAA4C;IAC3D,YAAY,EAAE,qBAAqB;IACnC,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,qDAAqD;IAC5D,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,SAAS;CAC7B,CAAA;AAEY,QAAA,kCAAkC,GAAG,uCAAS;KACxD,KAAK,CAAC,sCAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC;;;;CAI9C,CAAC;IACE,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC;;CAErD,CAAC;IACE,MAAM,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;CAEzE,CAAC;IACE,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC;;;;;;CAMhD,CAAC;IACE,eAAe,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;;;;;CAMxD,CAAC;IACE,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC;;CAEzD,CAAC;IACE,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;CAEvD,CAAC;IACE,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;;CAEtD,CAAC;IACE,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;CAErD,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotHttpImportInstructionsSchema: 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>;
+}, {
+    ignore_errors: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEnum<["meta", "import"]>, "many">]>, string[], boolean | ("meta" | "import")[]>>;
+}>, {
+    robot: z.ZodLiteral<"/http/import">;
+    url: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    url_delimiter: z.ZodDefault<z.ZodString>;
+    headers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    force_name: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+    import_on_errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    fail_fast: z.ZodDefault<z.ZodBoolean>;
+}>, "strict", z.ZodTypeAny, {
+    headers: string[];
+    url: string | string[];
+    robot: "/http/import";
+    result: boolean;
+    ignore_errors: string[];
+    url_delimiter: string;
+    force_name: string | string[] | null;
+    import_on_errors: string[];
+    fail_fast: boolean;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+}, {
+    url: string | string[];
+    robot: "/http/import";
+    headers?: string[] | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | undefined;
+    ignore_errors?: boolean | ("meta" | "import")[] | undefined;
+    url_delimiter?: string | undefined;
+    force_name?: string | string[] | null | undefined;
+    import_on_errors?: string[] | undefined;
+    fail_fast?: boolean | undefined;
+}>;
+export type RobotHttpImportInstructions = z.infer<typeof robotHttpImportInstructionsSchema>;
+export type RobotHttpImportInstructionsInput = z.input<typeof robotHttpImportInstructionsSchema>;
+//# sourceMappingURL=http-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-import.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/http-import.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,SA2BlB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCnC,CAAA;AAEX,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA"}

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotHttpImportInstructionsSchema = 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,
+    docs_redirect_from: ['/docs/import-files-over-http/'],
+    example_code: {
+        steps: {
+            imported: {
+                robot: '/http/import',
+                url: 'https://demos.transloadit.com/inputs/chameleon.jpg',
+            },
+        },
+    },
+    example_code_description: 'Import an image from a specific URL:',
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Importing',
+    purpose_sentence: 'imports any file that is publicly available via a web URL into Transloadit',
+    purpose_verb: 'import',
+    purpose_word: 'Webservers',
+    purpose_words: 'Import files from web servers',
+    service_slug: 'file-importing',
+    slot_count: 10,
+    title: 'Import files from web servers',
+    typical_file_size_mb: 1.2,
+    typical_file_type: 'file',
+};
+exports.robotHttpImportInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotImport)
+    .extend({
+    robot: zod_1.z.literal('/http/import').describe(`
+The result of this <dfn>Robot</dfn> will carry a field \`import_url\` in their metadata, which references the URL from which they were imported. Further conversion results that use this file will also carry this \`import_url\` field. This allows you to to match conversion results with the original import URL that you used.
+
+This <dfn>Robot</dfn> knows to interpret links to files on these services:
+
+- Dropbox
+- Google Drive
+- Google Docs
+- OneDrive
+
+Instead of downloading the HTML page previewing the file, the actual file itself will be imported.
+`),
+    url: zod_1.z.union([zod_1.z.string().url(), zod_1.z.array(zod_1.z.string().url())]).describe(`
+The URL from which the file to be imported can be retrieved.
+
+You can also specify an array of URLs or a string of \`|\` delimited URLs to import several files at once. Please also check the \`url_delimiter\` parameter for that.
+`),
+    url_delimiter: zod_1.z.string().default('|').describe(`
+Provides the delimiter that is used to split the URLs in your \`url\` parameter value.
+`),
+    headers: zod_1.z.array(zod_1.z.string()).default([]).describe(`
+Custom headers to be sent for file import.
+
+This is an empty array by default, such that no additional headers except the necessary ones (e.g. Host) are sent.
+`),
+    force_name: zod_1.z
+        .union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())])
+        .nullable()
+        .default(null).describe(`
+Custom name for the imported file(s). Defaults to \`null\`, which means the file names are derived from the supplied URL(s).
+`),
+    import_on_errors: zod_1.z.array(zod_1.z.string()).default([]).describe(`
+Setting this to \`"meta"\` will still import the file on metadata extraction errors. \`ignore_errors\` is similar, it also ignores the error and makes sure the Robot doesn't stop, but it doesn't import the file.
+`),
+    fail_fast: zod_1.z.boolean().default(false).describe(`
+Disable the internal retry mechanism, and fail immediately if a resource can't be imported. This can be useful for performance critical applications.
+`),
+})
+    .strict();
+//# sourceMappingURL=http-import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-import.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/http-import.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAsE;AAGzD,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,EAAE;IACd,eAAe,EAAE,GAAG;IACpB,YAAY,EAAE,EAAE;IAChB,kBAAkB,EAAE,CAAC,+BAA+B,CAAC;IACrD,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,QAAQ,EAAE;gBACR,KAAK,EAAE,cAAc;gBACrB,GAAG,EAAE,oDAAoD;aAC1D;SACF;KACF;IACD,wBAAwB,EAAE,sCAAsC;IAChE,cAAc,EAAE,CAAC;IACjB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,gBAAgB;IAC/B,gBAAgB,EAAE,4EAA4E;IAC9F,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,iCAAiC,GAAG,uCAAS;KACvD,KAAK,CAAC,yCAAW,CAAC;KAClB,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC;;;;;;;;;;;CAW7C,CAAC;IACE,GAAG,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;;;;CAIxE,CAAC;IACE,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;;CAEnD,CAAC;IACE,OAAO,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC;;;;CAIrD,CAAC;IACE,UAAU,EAAE,OAAC;SACV,KAAK,CAAC,CAAC,OAAC,CAAC,MAAM,EAAE,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;SACxC,QAAQ,EAAE;SACV,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC;;CAE7B,CAAC;IACE,gBAAgB,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC;;CAE9D,CAAC;IACE,SAAS,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;CAElD,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}