transloadit 3.0.2 → 4.0.0-2

package/dist/alphalib/types/robots/image-describe.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotImageDescribeInstructionsSchema: 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<"/image/describe">;
+    provider: z.ZodEnum<["aws", "gcp", "replicate", "fal", "transloadit"]>;
+    granularity: z.ZodDefault<z.ZodEnum<["full", "list"]>>;
+    format: z.ZodDefault<z.ZodEnum<["json", "meta", "text"]>>;
+    explicit_descriptions: z.ZodDefault<z.ZodBoolean>;
+}>, "strict", z.ZodTypeAny, {
+    format: "json" | "text" | "meta";
+    robot: "/image/describe";
+    result: boolean;
+    provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
+    granularity: "full" | "list";
+    explicit_descriptions: 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: "/image/describe";
+    provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
+    format?: "json" | "text" | "meta" | 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;
+    granularity?: "full" | "list" | undefined;
+    explicit_descriptions?: boolean | undefined;
+}>;
+export type RobotImageDescribeInstructions = z.infer<typeof robotImageDescribeInstructionsSchema>;
+//# sourceMappingURL=image-describe.d.ts.map

package/dist/alphalib/types/robots/image-describe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-describe.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-describe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAE9D,eAAO,MAAM,IAAI,EAAE,SA+BlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BtC,CAAA;AAEX,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA"}

package/dist/alphalib/types/robots/image-describe.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotImageDescribeInstructionsSchema = 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: {
+        steps: {
+            described: {
+                robot: '/image/describe',
+                use: ':original',
+                provider: 'aws',
+            },
+        },
+    },
+    example_code_description: 'Recognize objects in an uploaded image and store the labels in a JSON file:',
+    extended_description: `
+**Warning:** Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses third-party AI services. The providers (AWS, GCP) will evolve their models over time, giving different responses for the same input images. Avoid relying on exact responses in your tests and application. [{.alert .alert-warning}]
+`,
+    minimum_charge: 1572864,
+    output_factor: 0.05,
+    override_lvl1: 'Artificial Intelligence',
+    purpose_sentence: 'recognizes objects in images and returns them as English words',
+    purpose_verb: 'recognize',
+    purpose_word: 'recognize objects',
+    purpose_words: 'Recognize objects in images',
+    service_slug: 'artificial-intelligence',
+    slot_count: 10,
+    title: 'Recognize objects in images',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'image',
+};
+exports.robotImageDescribeInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .extend({
+    robot: zod_1.z.literal('/image/describe').describe(`
+You can use the labels that we return in your application to automatically classify images. You can also pass the labels down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain content.
+`),
+    provider: _instructions_primitives_ts_1.aiProviderSchema.describe(`
+Which AI provider to leverage.
+
+Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+`),
+    granularity: _instructions_primitives_ts_1.granularitySchema.describe(`
+Whether to return a full response (\`"full"\`) including confidence percentages for each found label, or just a flat list of labels (\`"list"\`).
+`),
+    format: zod_1.z.enum(['json', 'meta', 'text']).default('json').describe(`
+In what format to return the descriptions.
+
+- \`"json"\` returns a JSON file.
+- \`"meta"\` does not return a file, but stores the data inside Transloadit's file object (under \`\${file.meta.descriptions}\`) that's passed around between encoding <dfn>Steps</dfn>, so that you can use the values to burn the data into videos, filter on them, etc.
+`),
+    explicit_descriptions: zod_1.z.boolean().default(false).describe(`
+Whether to return only explicit or only non-explicit descriptions of the provided image. Explicit descriptions include labels for NSFW content (nudity, violence, etc). If set to \`false\`, only non-explicit descriptions (such as human or chair) will be returned. If set to \`true\`, only explicit descriptions will be returned.
+
+The possible descriptions depend on the chosen provider. The list of labels from AWS can be found [in their documentation](https://docs.aws.amazon.com/rekognition/latest/dg/moderation.html#moderation-api). GCP labels the image based on five categories, as described [in their documentation](https://cloud.google.com/vision/docs/detecting-safe-search).
+
+For an example of how to automatically reject NSFW content and malware, please check out this [blog post](/blog/2022/07/deny-image-uploads/).
+`),
+})
+    .strict();
+//# sourceMappingURL=image-describe.js.map

package/dist/alphalib/types/robots/image-describe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-describe.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-describe.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAKsC;AAGzB,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,SAAS,EAAE;gBACT,KAAK,EAAE,iBAAiB;gBACxB,GAAG,EAAE,WAAW;gBAChB,QAAQ,EAAE,KAAK;aAChB;SACF;KACF;IACD,wBAAwB,EACtB,6EAA6E;IAC/E,oBAAoB,EAAE;;CAEvB;IACC,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,yBAAyB;IACxC,gBAAgB,EAAE,gEAAgE;IAClF,YAAY,EAAE,WAAW;IACzB,YAAY,EAAE,mBAAmB;IACjC,aAAa,EAAE,6BAA6B;IAC5C,YAAY,EAAE,yBAAyB;IACvC,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,6BAA6B;IACpC,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,OAAO;CAC3B,CAAA;AAEY,QAAA,oCAAoC,GAAG,uCAAS;KAC1D,KAAK,CAAC,sCAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC;;CAEhD,CAAC;IACE,QAAQ,EAAE,8CAAgB,CAAC,QAAQ,CAAC;;;;CAIvC,CAAC;IACE,WAAW,EAAE,+CAAiB,CAAC,QAAQ,CAAC;;CAE3C,CAAC;IACE,MAAM,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC;;;;;CAKrE,CAAC;IACE,qBAAqB,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;;;;;CAM9D,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/image-facedetect.d.ts

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import type { RobotMeta } from './_instructions-primitives.ts';
+export declare const meta: RobotMeta;
+export declare const robotImageFacedetectInstructionsSchema: 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<"/image/facedetect">;
+    provider: z.ZodOptional<z.ZodEnum<["aws", "gcp", "replicate", "fal", "transloadit"]>>;
+    crop: z.ZodDefault<z.ZodBoolean>;
+    crop_padding: z.ZodDefault<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<["jpg", "png", "preserve", "tiff"]>>;
+    min_confidence: z.ZodDefault<z.ZodNumber>;
+    faces: z.ZodDefault<z.ZodUnion<[z.ZodEnum<["each", "group", "max-confidence", "max-size"]>, z.ZodNumber]>>;
+}>, "strict", z.ZodTypeAny, {
+    format: "jpg" | "png" | "preserve" | "tiff";
+    robot: "/image/facedetect";
+    result: boolean;
+    crop: boolean;
+    crop_padding: string;
+    min_confidence: number;
+    faces: number | "each" | "group" | "max-confidence" | "max-size";
+    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;
+    provider?: "aws" | "gcp" | "replicate" | "fal" | "transloadit" | undefined;
+}, {
+    robot: "/image/facedetect";
+    format?: "jpg" | "png" | "preserve" | "tiff" | 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;
+    provider?: "aws" | "gcp" | "replicate" | "fal" | "transloadit" | undefined;
+    crop?: boolean | undefined;
+    crop_padding?: string | undefined;
+    min_confidence?: number | undefined;
+    faces?: number | "each" | "group" | "max-confidence" | "max-size" | undefined;
+}>;
+export type RobotImageFacedetectInstructions = z.infer<typeof robotImageFacedetectInstructionsSchema>;
+//# sourceMappingURL=image-facedetect.d.ts.map

package/dist/alphalib/types/robots/image-facedetect.d.ts.map

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

package/dist/alphalib/types/robots/image-facedetect.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.robotImageFacedetectInstructionsSchema = 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: {
+        steps: {
+            faces_detected: {
+                robot: '/image/facedetect',
+                use: ':original',
+                crop: true,
+                faces: 'each',
+                crop_padding: '10px',
+            },
+        },
+    },
+    example_code_description: 'Detect all faces in uploaded images, crop them, and save as separate images:',
+    minimum_charge: 5242880,
+    output_factor: 0.2,
+    override_lvl1: 'Artificial Intelligence',
+    purpose_sentence: 'detects faces in images and can return either their coordinates or the faces themselves as new images',
+    purpose_verb: 'detect',
+    purpose_word: 'detect faces',
+    purpose_words: 'Detect faces in images',
+    redirect_from: ['/services/computer-vision/image-facedetect/'],
+    service_slug: 'artificial-intelligence',
+    slot_count: 20,
+    title: 'Detect faces in images',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'image',
+};
+exports.robotImageFacedetectInstructionsSchema = _instructions_primitives_ts_1.robotBase
+    .merge(_instructions_primitives_ts_1.robotUse)
+    .extend({
+    robot: zod_1.z.literal('/image/facedetect').describe(`
+You can specify padding around the extracted faces, tailoring the output for your needs.
+
+This <dfn>Robot</dfn> works well together with [🤖/image/resize](/docs/transcoding/image-manipulation/image-resize/) to bring the full power of resized and optimized images to your website or app.
+
+<div class="alert alert-note">
+
+**How to improve the accuracy:**
+
+- Ensure that your pictures have the correct orientation. This <dfn>Robot</dfn> achieves the best performance when the faces in the image are oriented upright and not rotated.
+- If the <dfn>Robot</dfn> detects objects other than a face, you can use \`"faces": "max-confidence"\` within your <dfn>Template</dfn> for selecting only the detection with the highest confidence.
+- The number of returned detections can also be controlled using the \`min_confidence\` parameter. Increasing its value will yield less results but each with a higher confidence. Decreasing the value, on the other hand, will provide more results but may also include objects other than faces.
+
+</div>
+`),
+    provider: _instructions_primitives_ts_1.aiProviderSchema.optional().describe(`
+Which AI provider to leverage.
+
+Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+`),
+    crop: zod_1.z.boolean().default(false).describe(`
+Determine if the detected faces should be extracted. If this option is set to \`false\`, then the <dfn>Robot</dfn> returns the input image again, but with the coordinates of all detected faces attached to \`file.meta.faces\` in the result JSON. If this parameter is set to \`true\`, the <dfn>Robot</dfn> will output all detected faces as images.
+`),
+    crop_padding: zod_1.z
+        .string()
+        .regex(/^\d+(px|%)$/)
+        .default('5px').describe(`
+Specifies how much padding is added to the extracted face images if \`crop\` is set to \`true\`. Values can be in \`px\` (pixels) or \`%\` (percentage of the width and height of the particular face image).
+`),
+    format: zod_1.z.enum(['jpg', 'png', 'preserve', 'tiff']).default('preserve').describe(`
+Determines the output format of the extracted face images if \`crop\` is set to \`true\`.
+
+The default value \`"preserve"\` means that the input image format is re-used.
+`),
+    min_confidence: zod_1.z.number().int().min(0).max(100).default(70).describe(`
+Specifies the minimum confidence that a detected face must have. Only faces which have a higher confidence value than this threshold will be included in the result.
+`),
+    faces: zod_1.z
+        .union([zod_1.z.enum(['each', 'group', 'max-confidence', 'max-size']), zod_1.z.number().int()])
+        .default('each').describe(`
+Determines which of the detected faces should be returned. Valid values are:
+
+- \`"each"\` — each face is returned individually.
+- \`"max-confidence"\` — only the face with the highest confidence value is returned.
+- \`"max-size"\` — only the face with the largest area is returned.
+- \`"group"\` — all detected faces are grouped together into one rectangle that contains all faces.
+- any integer — the faces are sorted by their top-left corner and the integer determines the index of the returned face. Be aware the values are zero-indexed, meaning that \`faces: 0\` will return the first face. If no face for a given index exists, no output is produced.
+
+For the following examples, the input image is:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-unsplash.jpg)
+
+<br>
+
+\`faces: "each"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-0.jpg)
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
+
+<br>
+
+\`faces: "max-confidence"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
+
+<br>
+
+\`faces: "max-size"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
+
+<br>
+
+\`faces: "group"\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-group.jpg)
+
+<br>
+
+\`faces: 0\` applied:
+
+![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-0.jpg)
+`),
+})
+    .strict();
+//# sourceMappingURL=image-facedetect.js.map

package/dist/alphalib/types/robots/image-facedetect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-facedetect.js","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-facedetect.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,+EAAqF;AAGxE,QAAA,IAAI,GAAc;IAC7B,yBAAyB,EAAE,IAAI;IAC/B,UAAU,EAAE,CAAC;IACb,eAAe,EAAE,CAAC;IAClB,YAAY,EAAE,CAAC;IACf,YAAY,EAAE;QACZ,KAAK,EAAE;YACL,cAAc,EAAE;gBACd,KAAK,EAAE,mBAAmB;gBAC1B,GAAG,EAAE,WAAW;gBAChB,IAAI,EAAE,IAAI;gBACV,KAAK,EAAE,MAAM;gBACb,YAAY,EAAE,MAAM;aACrB;SACF;KACF;IACD,wBAAwB,EACtB,8EAA8E;IAChF,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,GAAG;IAClB,aAAa,EAAE,yBAAyB;IACxC,gBAAgB,EACd,uGAAuG;IACzG,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE,cAAc;IAC5B,aAAa,EAAE,wBAAwB;IACvC,aAAa,EAAE,CAAC,6CAA6C,CAAC;IAC9D,YAAY,EAAE,yBAAyB;IACvC,UAAU,EAAE,EAAE;IACd,KAAK,EAAE,wBAAwB;IAC/B,oBAAoB,EAAE,GAAG;IACzB,iBAAiB,EAAE,OAAO;CAC3B,CAAA;AAEY,QAAA,sCAAsC,GAAG,uCAAS;KAC5D,KAAK,CAAC,sCAAQ,CAAC;KACf,MAAM,CAAC;IACN,KAAK,EAAE,OAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;CAclD,CAAC;IACE,QAAQ,EAAE,8CAAgB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC;;;;CAIlD,CAAC;IACE,IAAI,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;CAE7C,CAAC;IACE,YAAY,EAAE,OAAC;SACZ,MAAM,EAAE;SACR,KAAK,CAAC,aAAa,CAAC;SACpB,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;;CAE9B,CAAC;IACE,MAAM,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC;;;;CAInF,CAAC;IACE,cAAc,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC;;CAEzE,CAAC;IACE,KAAK,EAAE,OAAC;SACL,KAAK,CAAC,CAAC,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;SAClF,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C/B,CAAC;CACC,CAAC;KACD,MAAM,EAAE,CAAA"}

package/dist/alphalib/types/robots/image-generate.d.ts

@@ -0,0 +1,229 @@
+import { z } from 'zod';
+export declare const robotImageGenerateInstructionsSchema: 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<"/image/generate">;
+    model: z.ZodString;
+    prompt: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<["jpeg", "png", "gif", "webp", "svg"]>>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    aspectRatio: z.ZodOptional<z.ZodString>;
+    height: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    style: z.ZodOptional<z.ZodString>;
+}>, "strict", z.ZodTypeAny, {
+    prompt: string;
+    robot: "/image/generate";
+    result: boolean;
+    model: string;
+    style?: string | undefined;
+    format?: "gif" | "jpeg" | "png" | "svg" | "webp" | 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;
+    width?: number | undefined;
+    height?: number | undefined;
+    seed?: number | undefined;
+    aspectRatio?: string | undefined;
+}, {
+    prompt: string;
+    robot: "/image/generate";
+    model: string;
+    style?: string | undefined;
+    format?: "gif" | "jpeg" | "png" | "svg" | "webp" | 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;
+    seed?: number | undefined;
+    aspectRatio?: string | undefined;
+}>;
+export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: 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;
+    }>]>>;
+}>, {
+    robot: z.ZodLiteral<"/image/generate">;
+    model: z.ZodString;
+    prompt: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<["jpeg", "png", "gif", "webp", "svg"]>>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    aspectRatio: z.ZodOptional<z.ZodString>;
+    height: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    style: z.ZodOptional<z.ZodString>;
+}>, {
+    result: z.ZodUnion<[z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>;
+    provider: z.ZodOptional<z.ZodString>;
+}>, "strict", z.ZodTypeAny, {
+    prompt: string;
+    robot: "/image/generate";
+    result: boolean | "debug";
+    model: string;
+    style?: string | undefined;
+    format?: "gif" | "jpeg" | "png" | "svg" | "webp" | 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;
+    width?: number | undefined;
+    height?: number | undefined;
+    provider?: string | undefined;
+    seed?: number | undefined;
+    aspectRatio?: string | undefined;
+}, {
+    prompt: string;
+    robot: "/image/generate";
+    model: string;
+    style?: string | undefined;
+    format?: "gif" | "jpeg" | "png" | "svg" | "webp" | undefined;
+    output_meta?: boolean | Record<string, boolean> | undefined;
+    result?: boolean | "debug" | 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;
+    provider?: string | undefined;
+    seed?: number | undefined;
+    aspectRatio?: string | undefined;
+}>;
+export type RobotImageGenerateInstructions = z.infer<typeof robotImageGenerateInstructionsSchema>;
+export type RobotImageGenerateInstructionsWithHiddenFields = z.infer<typeof robotImageGenerateInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=image-generate.d.ts.map

package/dist/alphalib/types/robots/image-generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../../src/alphalib/types/robots/image-generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA"}