@eraserlabs/eraser-mcp 0.2.0 → 0.3.1-next.0

package/dist/descriptions/bpmn.d.ts

@@ -0,0 +1,2 @@
+export declare const BPMN_DESCRIPTION = "Render a BPMN (Business Process Model and Notation) diagram. Use Eraser's BPMN syntax.\n\nExample syntax:\n```\ntitle Order Fulfillment Process\n\n// Swimlanes (pools)\nCustomer [color: blue] {\n  Place Order [type: event, icon: shopping-cart]\n  Receive Confirmation [type: event, icon: mail]\n  Receive Package [type: event, icon: package]\n}\n\nSales [color: green] {\n  Process Order [icon: clipboard]\n  Check Inventory [icon: database]\n  In Stock? [type: gateway, icon: help-circle]\n  Create Backorder [icon: clock]\n  Confirm Order [icon: check]\n}\n\nWarehouse [color: orange] {\n  Pick Items [icon: box]\n  Pack Order [icon: package]\n  Ship Order [icon: truck]\n}\n\n// Flow connections (use --> for message flows between pools)\nPlace Order --> Process Order: Order details\nProcess Order > Check Inventory\nCheck Inventory > In Stock?\nIn Stock? > Confirm Order: Yes\nIn Stock? > Create Backorder: No\nConfirm Order --> Receive Confirmation: Confirmation email\nConfirm Order > Pick Items\nPick Items > Pack Order\nPack Order > Ship Order\nShip Order --> Receive Package: Delivery\n```";
+//# sourceMappingURL=bpmn.d.ts.map

package/dist/descriptions/bpmn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bpmn.d.ts","sourceRoot":"","sources":["../../src/descriptions/bpmn.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,glCAsCtB,CAAC"}

package/dist/descriptions/bpmn.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BPMN_DESCRIPTION = void 0;
+exports.BPMN_DESCRIPTION = `Render a BPMN (Business Process Model and Notation) diagram. Use Eraser's BPMN syntax.
+
+Example syntax:
+\`\`\`
+title Order Fulfillment Process
+
+// Swimlanes (pools)
+Customer [color: blue] {
+  Place Order [type: event, icon: shopping-cart]
+  Receive Confirmation [type: event, icon: mail]
+  Receive Package [type: event, icon: package]
+}
+
+Sales [color: green] {
+  Process Order [icon: clipboard]
+  Check Inventory [icon: database]
+  In Stock? [type: gateway, icon: help-circle]
+  Create Backorder [icon: clock]
+  Confirm Order [icon: check]
+}
+
+Warehouse [color: orange] {
+  Pick Items [icon: box]
+  Pack Order [icon: package]
+  Ship Order [icon: truck]
+}
+
+// Flow connections (use --> for message flows between pools)
+Place Order --> Process Order: Order details
+Process Order > Check Inventory
+Check Inventory > In Stock?
+In Stock? > Confirm Order: Yes
+In Stock? > Create Backorder: No
+Confirm Order --> Receive Confirmation: Confirmation email
+Confirm Order > Pick Items
+Pick Items > Pack Order
+Pack Order > Ship Order
+Ship Order --> Receive Package: Delivery
+\`\`\``;

package/dist/descriptions/cloudArchitecture.d.ts

@@ -0,0 +1,2 @@
+export declare const CLOUD_ARCHITECTURE_DESCRIPTION = "Render a cloud architecture diagram. Use Eraser's cloud architecture syntax.\n\nExample syntax:\n```\ntitle AWS Microservices Architecture\n\n// Groups with cloud provider icons\nAWS Cloud [icon: aws] {\n  VPC [icon: aws-vpc] {\n    Public Subnet {\n      ALB [icon: aws-elb]\n      NAT Gateway [icon: aws-nat-gateway]\n    }\n    Private Subnet {\n      ECS Cluster [icon: aws-ecs] {\n        API Service [icon: aws-lambda]\n        Worker Service [icon: aws-lambda]\n      }\n      RDS [icon: aws-rds]\n      ElastiCache [icon: aws-elasticache]\n    }\n  }\n  S3 [icon: aws-s3]\n  CloudFront [icon: aws-cloudfront]\n}\n\nUsers [icon: users]\n\n// Connections\nUsers > CloudFront\nCloudFront > ALB\nALB > API Service\nAPI Service > RDS\nAPI Service > ElastiCache\nWorker Service > S3\n```";
+//# sourceMappingURL=cloudArchitecture.d.ts.map

package/dist/descriptions/cloudArchitecture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudArchitecture.d.ts","sourceRoot":"","sources":["../../src/descriptions/cloudArchitecture.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,0xBAmCpC,CAAC"}

package/dist/descriptions/cloudArchitecture.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLOUD_ARCHITECTURE_DESCRIPTION = void 0;
+exports.CLOUD_ARCHITECTURE_DESCRIPTION = `Render a cloud architecture diagram. Use Eraser's cloud architecture syntax.
+
+Example syntax:
+\`\`\`
+title AWS Microservices Architecture
+
+// Groups with cloud provider icons
+AWS Cloud [icon: aws] {
+  VPC [icon: aws-vpc] {
+    Public Subnet {
+      ALB [icon: aws-elb]
+      NAT Gateway [icon: aws-nat-gateway]
+    }
+    Private Subnet {
+      ECS Cluster [icon: aws-ecs] {
+        API Service [icon: aws-lambda]
+        Worker Service [icon: aws-lambda]
+      }
+      RDS [icon: aws-rds]
+      ElastiCache [icon: aws-elasticache]
+    }
+  }
+  S3 [icon: aws-s3]
+  CloudFront [icon: aws-cloudfront]
+}
+
+Users [icon: users]
+
+// Connections
+Users > CloudFront
+CloudFront > ALB
+ALB > API Service
+API Service > RDS
+API Service > ElastiCache
+Worker Service > S3
+\`\`\``;

package/dist/descriptions/erd.d.ts

@@ -0,0 +1,2 @@
+export declare const ERD_DESCRIPTION = "Render an entity-relationship diagram. Use Eraser's ERD syntax.\n\nExample syntax:\n```\ntitle E-commerce Database\n\n// Define tables with columns\nusers [icon: user, color: blue] {\n  id int pk\n  email string\n  name string\n  created_at timestamp\n}\n\norders [icon: shopping-cart, color: green] {\n  id int pk\n  user_id int\n  total decimal\n  status string\n  created_at timestamp\n}\n\nproducts [icon: box, color: orange] {\n  id int pk\n  name string\n  price decimal\n  stock int\n}\n\norder_items [icon: list] {\n  order_id int pk\n  product_id int pk\n  quantity int\n  price decimal\n}\n\n// Relationships\nusers.id < orders.user_id\norders.id < order_items.order_id\nproducts.id < order_items.product_id\n```";
+//# sourceMappingURL=erd.d.ts.map

package/dist/descriptions/erd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erd.d.ts","sourceRoot":"","sources":["../../src/descriptions/erd.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,utBAwCrB,CAAC"}

package/dist/descriptions/erd.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERD_DESCRIPTION = void 0;
+exports.ERD_DESCRIPTION = `Render an entity-relationship diagram. Use Eraser's ERD syntax.
+
+Example syntax:
+\`\`\`
+title E-commerce Database
+
+// Define tables with columns
+users [icon: user, color: blue] {
+  id int pk
+  email string
+  name string
+  created_at timestamp
+}
+
+orders [icon: shopping-cart, color: green] {
+  id int pk
+  user_id int
+  total decimal
+  status string
+  created_at timestamp
+}
+
+products [icon: box, color: orange] {
+  id int pk
+  name string
+  price decimal
+  stock int
+}
+
+order_items [icon: list] {
+  order_id int pk
+  product_id int pk
+  quantity int
+  price decimal
+}
+
+// Relationships
+users.id < orders.user_id
+orders.id < order_items.order_id
+products.id < order_items.product_id
+\`\`\``;

package/dist/descriptions/flowchart.d.ts

@@ -0,0 +1,2 @@
+export declare const FLOWCHART_DESCRIPTION = "Render a flowchart diagram. Use Eraser's flowchart syntax. Prefer horizontal layout (direction right) unless the user wants a vertical diagram.\n\nExample syntax:\n```\ntitle User Registration Flow\ndirection right\n\n// Nodes with shapes and icons\nStart [shape: oval, icon: play]\nEnter Details [icon: edit]\nValid Email? [shape: diamond, icon: help-circle]\nSend Verification [icon: mail]\nEmail Verified? [shape: diamond]\nCreate Account [icon: user-plus, color: green]\nShow Error [icon: alert-triangle, color: red]\nEnd [shape: oval, icon: check]\n\n// Groups\nValidation [color: blue] {\n  Check Password Strength [icon: lock]\n  Password OK? [shape: diamond]\n}\n\n// Connections with labels\nStart > Enter Details\nEnter Details > Valid Email?\nValid Email? > Send Verification: Yes\nValid Email? > Show Error: No\nSend Verification > Email Verified?\nEmail Verified? > Create Account: Yes\nEmail Verified? > Show Error: No\nCreate Account > End\nShow Error > Enter Details\n```";
+//# sourceMappingURL=flowchart.d.ts.map

package/dist/descriptions/flowchart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowchart.d.ts","sourceRoot":"","sources":["../../src/descriptions/flowchart.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,g+BAiC3B,CAAC"}

package/dist/descriptions/flowchart.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLOWCHART_DESCRIPTION = void 0;
+exports.FLOWCHART_DESCRIPTION = `Render a flowchart diagram. Use Eraser's flowchart syntax. Prefer horizontal layout (direction right) unless the user wants a vertical diagram.
+
+Example syntax:
+\`\`\`
+title User Registration Flow
+direction right
+
+// Nodes with shapes and icons
+Start [shape: oval, icon: play]
+Enter Details [icon: edit]
+Valid Email? [shape: diamond, icon: help-circle]
+Send Verification [icon: mail]
+Email Verified? [shape: diamond]
+Create Account [icon: user-plus, color: green]
+Show Error [icon: alert-triangle, color: red]
+End [shape: oval, icon: check]
+
+// Groups
+Validation [color: blue] {
+  Check Password Strength [icon: lock]
+  Password OK? [shape: diamond]
+}
+
+// Connections with labels
+Start > Enter Details
+Enter Details > Valid Email?
+Valid Email? > Send Verification: Yes
+Valid Email? > Show Error: No
+Send Verification > Email Verified?
+Email Verified? > Create Account: Yes
+Email Verified? > Show Error: No
+Create Account > End
+Show Error > Enter Details
+\`\`\``;

package/dist/descriptions/sequenceDiagram.d.ts

@@ -0,0 +1,2 @@
+export declare const SEQUENCE_DIAGRAM_DESCRIPTION = "Render a sequence diagram. Use Eraser's sequence diagram syntax.\n\nExample syntax:\n```\ntitle Authentication Flow\nautoNumber on\n\nClient [icon: monitor, color: gray]\nServer [icon: server, color: blue]\nService [icon: tool, color: green]\n\nClient > Server: Data request\nactivate Server\nServer <> Service: Service request\n\nloop [label: until success, color: green] {\n  Service > Service: Check availability\n}\n\nServer - Service: Data processing\nServer --> Client: Data response\ndeactivate Server\n```";
+//# sourceMappingURL=sequenceDiagram.d.ts.map

package/dist/descriptions/sequenceDiagram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceDiagram.d.ts","sourceRoot":"","sources":["../../src/descriptions/sequenceDiagram.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,sgBAsBlC,CAAC"}

package/dist/descriptions/sequenceDiagram.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEQUENCE_DIAGRAM_DESCRIPTION = void 0;
+exports.SEQUENCE_DIAGRAM_DESCRIPTION = `Render a sequence diagram. Use Eraser's sequence diagram syntax.
+
+Example syntax:
+\`\`\`
+title Authentication Flow
+autoNumber on
+
+Client [icon: monitor, color: gray]
+Server [icon: server, color: blue]
+Service [icon: tool, color: green]
+
+Client > Server: Data request
+activate Server
+Server <> Service: Service request
+
+loop [label: until success, color: green] {
+  Service > Service: Check availability
+}
+
+Server - Service: Data processing
+Server --> Client: Data response
+deactivate Server
+\`\`\``;

package/dist/descriptions/tools.d.ts

@@ -0,0 +1,4 @@
+export declare const CREATE_FILE_DESCRIPTION = "Create a new Eraser file with markdown notes and/or diagram elements. Supports embedded diagram code blocks in markdown (e.g., ```flowchart-diagram) which are automatically converted to interactive canvas diagrams. Additionally supports standalone diagram elements via the elements array.";
+export declare const RENDER_PROMPT_DESCRIPTION = "Generate a diagram using AI from a natural language prompt, existing code, infrastructure configuration, or other diagram languages. Best for when you want AI to create the diagram code for you.";
+export declare const RENDER_ELEMENTS_DESCRIPTION = "Render multiple diagram elements. Advanced use case for rendering multiple diagrams at once.";
+//# sourceMappingURL=tools.d.ts.map

package/dist/descriptions/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/descriptions/tools.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,qSACgQ,CAAC;AAErS,eAAO,MAAM,yBAAyB,uMACgK,CAAC;AAEvM,eAAO,MAAM,2BAA2B,iGACwD,CAAC"}

package/dist/descriptions/tools.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RENDER_ELEMENTS_DESCRIPTION = exports.RENDER_PROMPT_DESCRIPTION = exports.CREATE_FILE_DESCRIPTION = void 0;
+exports.CREATE_FILE_DESCRIPTION = 'Create a new Eraser file with markdown notes and/or diagram elements. Supports embedded diagram code blocks in markdown (e.g., ```flowchart-diagram) which are automatically converted to interactive canvas diagrams. Additionally supports standalone diagram elements via the elements array.';
+exports.RENDER_PROMPT_DESCRIPTION = 'Generate a diagram using AI from a natural language prompt, existing code, infrastructure configuration, or other diagram languages. Best for when you want AI to create the diagram code for you.';
+exports.RENDER_ELEMENTS_DESCRIPTION = 'Render multiple diagram elements. Advanced use case for rendering multiple diagrams at once.';

package/dist/schemas/createFile.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const createFileSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    markdown: z.ZodOptional<z.ZodString>;
+    elements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        diagramType: z.ZodNativeEnum<typeof import("./shared").DiagramTypes>;
+        code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+    }, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+    }>, "many">>;
+    linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+}, "strip", z.ZodTypeAny, {
+    linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    title?: string | undefined;
+    markdown?: string | undefined;
+    elements?: {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+    }[] | undefined;
+}, {
+    linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    title?: string | undefined;
+    markdown?: string | undefined;
+    elements?: {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+    }[] | undefined;
+}>;
+export type CreateFileInput = z.infer<typeof createFileSchema>;
+//# sourceMappingURL=createFile.d.ts.map

package/dist/schemas/createFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFile.d.ts","sourceRoot":"","sources":["../../src/schemas/createFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB3B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/createFile.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSchema = void 0;
+const zod_1 = require("zod");
+const shared_1 = require("./shared");
+exports.createFileSchema = zod_1.z.object({
+    title: zod_1.z.string().optional().describe('Title for the file.'),
+    markdown: zod_1.z
+        .string()
+        .optional()
+        .describe('Markdown content for notes. Supports diagram code blocks (e.g., ```flowchart-diagram) which are converted to embedded diagrams.'),
+    elements: zod_1.z
+        .array(zod_1.z.object({
+        type: zod_1.z.literal('diagram'),
+        diagramType: shared_1.DiagramTypesEnum,
+        code: zod_1.z.string(),
+    }))
+        .optional()
+        .describe('Standalone diagram elements using diagram DSL syntax. Will be added to canvas.'),
+    linkAccess: shared_1.LinkAccessEnum.optional().describe('Optional link sharing access level. Defaults to using team config.'),
+});

package/dist/schemas/renderElements.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+export declare const renderElementsSchema: z.ZodObject<{
+    imageQuality: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    returnImageAsFile: z.ZodOptional<z.ZodBoolean>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+} & {
+    elements: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        diagramType: z.ZodNativeEnum<typeof import("./shared").DiagramTypes>;
+        code: z.ZodString;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    imageQuality: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    returnImageAsFile: z.ZodOptional<z.ZodBoolean>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+} & {
+    elements: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        diagramType: z.ZodNativeEnum<typeof import("./shared").DiagramTypes>;
+        code: z.ZodString;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    imageQuality: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    returnImageAsFile: z.ZodOptional<z.ZodBoolean>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+} & {
+    elements: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        diagramType: z.ZodNativeEnum<typeof import("./shared").DiagramTypes>;
+        code: z.ZodString;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }, {
+        type: "diagram";
+        code: string;
+        diagramType: import("./shared").DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>;
+export type RenderElementsInput = z.infer<typeof renderElementsSchema>;
+//# sourceMappingURL=renderElements.d.ts.map

package/dist/schemas/renderElements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderElements.d.ts","sourceRoot":"","sources":["../../src/schemas/renderElements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAIjB,CAAC;AAEjB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/renderElements.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderElementsSchema = void 0;
+const zod_1 = require("zod");
+const shared_1 = require("./shared");
+exports.renderElementsSchema = shared_1.renderOptionsSchema
+    .extend({
+    elements: zod_1.z.array(shared_1.diagramElementSchema),
+})
+    .passthrough();

package/dist/schemas/renderPrompt.d.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+export declare const renderPromptSchema: z.ZodObject<{
+    imageQuality: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    returnImageAsFile: z.ZodOptional<z.ZodBoolean>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+} & {
+    text: z.ZodString;
+    diagramType: z.ZodOptional<z.ZodString>;
+    priorRequestId: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contextId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["standard", "premium"]>>;
+    git: z.ZodOptional<z.ZodObject<{
+        repoName: z.ZodString;
+        orgName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        repoName: string;
+        orgName: string;
+    }, {
+        repoName: string;
+        orgName: string;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    imageQuality: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    returnImageAsFile: z.ZodOptional<z.ZodBoolean>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+} & {
+    text: z.ZodString;
+    diagramType: z.ZodOptional<z.ZodString>;
+    priorRequestId: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contextId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["standard", "premium"]>>;
+    git: z.ZodOptional<z.ZodObject<{
+        repoName: z.ZodString;
+        orgName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        repoName: string;
+        orgName: string;
+    }, {
+        repoName: string;
+        orgName: string;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    imageQuality: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    returnImageAsFile: z.ZodOptional<z.ZodBoolean>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+} & {
+    text: z.ZodString;
+    diagramType: z.ZodOptional<z.ZodString>;
+    priorRequestId: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contextId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["standard", "premium"]>>;
+    git: z.ZodOptional<z.ZodObject<{
+        repoName: z.ZodString;
+        orgName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        repoName: string;
+        orgName: string;
+    }, {
+        repoName: string;
+        orgName: string;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type RenderPromptInput = z.infer<typeof renderPromptSchema>;
+//# sourceMappingURL=renderPrompt.d.ts.map

package/dist/schemas/renderPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderPrompt.d.ts","sourceRoot":"","sources":["../../src/schemas/renderPrompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAUf,CAAC;AAEjB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/schemas/renderPrompt.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPromptSchema = void 0;
+const zod_1 = require("zod");
+const shared_1 = require("./shared");
+exports.renderPromptSchema = shared_1.renderOptionsSchema
+    .extend({
+    text: zod_1.z.string(),
+    diagramType: zod_1.z.string().optional(),
+    priorRequestId: zod_1.z.string().optional().describe('Allows editing a previously created diagram.'),
+    attachments: zod_1.z.array(zod_1.z.unknown()).optional(),
+    contextId: zod_1.z.string().optional().describe('ID of an AI preset belonging to the team.'),
+    mode: zod_1.z.enum(shared_1.aiModeSettings).optional(),
+    git: shared_1.gitRepoSchema.optional(),
+})
+    .passthrough();