@standby/mcp-server-chart 0.9.10

package/build/charts/radar.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.radar = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Radar chart data schema
+const data = zod_1.z.object({
+    name: zod_1.z.string(),
+    value: zod_1.z.number(),
+    group: zod_1.z.string().optional(),
+});
+// Radar chart input schema
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for radar chart, it should be an array of objects, each object contains a `name` field and a `value` field, such as, [{ name: 'Design', value: 70 }], when the data is grouped by `group`, the `group` field is required, such as, [{ name: 'Design', value: 70, group: 'Huawei' }].")
+        .nonempty({ message: "Radar chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+        lineWidth: zod_1.z
+            .number()
+            .optional()
+            .describe("Line width for the lines of chart, such as 4."),
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+// Radar chart tool descriptor
+const tool = {
+    name: "generate_radar_chart",
+    description: "Generate a radar chart to display multidimensional data (four dimensions or more), such as, evaluate Huawei and Apple phones in terms of five dimensions: ease of use, functionality, camera, benchmark scores, and battery life.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Radar Chart",
+        readOnlyHint: true,
+    },
+};
+exports.radar = {
+    schema,
+    tool,
+};

package/build/charts/sankey.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const sankey: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            target: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strip>>;
+        nodeAlign: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            right: "right";
+            center: "center";
+            left: "left";
+            justify: "justify";
+        }>>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/sankey.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sankey = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const data = zod_1.z.object({
+    source: zod_1.z.string(),
+    target: zod_1.z.string(),
+    value: zod_1.z.number(),
+});
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Date for sankey chart, such as, [{ source: 'Landing Page', target: 'Product Page', value: 50000 }, { source: 'Product Page', target: 'Add to Cart', value: 35000 }, { source: 'Add to Cart', target: 'Checkout', value: 25000 }, { source: 'Checkout', target: 'Payment', value: 15000 }, { source: 'Payment', target: 'Purchase Completed', value: 8000 }].")
+        .nonempty({ message: "Sankey chart data cannot be empty." }),
+    nodeAlign: zod_1.z
+        .enum(["left", "right", "justify", "center"])
+        .optional()
+        .default("center")
+        .describe("Alignment of nodes in the sankey chart, such as, 'left', 'right', 'justify', or 'center'."),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+const tool = {
+    name: "generate_sankey_chart",
+    description: "Generate a sankey chart to visualize the flow of data between different stages or categories, such as, the user journey from landing on a page to completing a purchase.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Sankey Chart",
+        readOnlyHint: true,
+    },
+};
+exports.sankey = {
+    schema,
+    tool,
+};

package/build/charts/scatter.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const scatter: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisXTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisYTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/scatter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scatter = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Scatter chart data schema
+const data = zod_1.z.object({
+    x: zod_1.z.number(),
+    y: zod_1.z.number(),
+    group: zod_1.z.string().optional().describe("Group name for the data point."),
+});
+// Scatter chart input schema
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for scatter chart, such as, [{ x: 10, y: 15 }], when the data is grouped, the group name can be specified in the `group` field, such as, [{ x: 10, y: 15, group: 'Group A' }].")
+        .nonempty({ message: "Scatter chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+    axisXTitle: base_1.AxisXTitleSchema,
+    axisYTitle: base_1.AxisYTitleSchema,
+};
+// Scatter chart tool descriptor
+const tool = {
+    name: "generate_scatter_chart",
+    description: "Generate a scatter chart to show the relationship between two variables, helps discover their relationship or trends, such as, the strength of correlation, data distribution patterns.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Scatter Chart",
+        readOnlyHint: true,
+    },
+};
+exports.scatter = {
+    schema,
+    tool,
+};

package/build/charts/treemap.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const treemap: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodNumber;
+            children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodNumber;
+                children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    value: z.ZodNumber;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/treemap.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.treemap = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Define recursive schema for hierarchical data.
+// The recursive schema is not supported by gemini, and other clients, so we use a non-recursive schema which can represent a tree structure with a fixed depth.
+// Ref: https://github.com/antvis/mcp-server-chart/issues/155
+// Ref: https://github.com/antvis/mcp-server-chart/issues/132
+const TreeNodeSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    value: zod_1.z.number(),
+    children: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string(),
+        value: zod_1.z.number(),
+        children: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z.string(),
+            value: zod_1.z.number(),
+        }))
+            .optional(),
+    }))
+        .optional(),
+});
+// Treemap chart input schema
+const schema = {
+    data: zod_1.z
+        .array(TreeNodeSchema)
+        .describe("Data for treemap chart which is a hierarchical structure, such as, [{ name: 'Design', value: 70, children: [{ name: 'Tech', value: 20 }] }], and the maximum depth is 3.")
+        .nonempty({ message: "Treemap chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+// Treemap chart tool descriptor
+const tool = {
+    name: "generate_treemap_chart",
+    description: "Generate a treemap chart to display hierarchical data and can intuitively show comparisons between items at the same level, such as, show disk space usage with treemap.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Treemap Chart",
+        readOnlyHint: true,
+    },
+};
+exports.treemap = {
+    schema,
+    tool,
+};

package/build/charts/venn.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const venn: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            value: z.ZodNumber;
+            sets: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/venn.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.venn = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const data = zod_1.z.object({
+    label: zod_1.z
+        .string()
+        .optional()
+        .describe("Label for the venn chart segment, such as 'A', 'B', or 'C'."),
+    value: zod_1.z
+        .number()
+        .describe("Value for the venn chart segment, such as 10, 20, or 30."),
+    sets: zod_1.z
+        .array(zod_1.z.string())
+        .describe("Array of set names that this segment belongs to, such as ['A', 'B'] for an intersection between sets A and B."),
+});
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for venn chart, such as, [{ label: 'A', value: 10, sets: ['A'] }, { label: 'B', value: 20, sets: ['B'] }, { label: 'C', value: 30, sets: ['C'] }, { label: 'AB', value: 5, sets: ['A', 'B'] }].")
+        .nonempty({ message: "Venn chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+const tool = {
+    name: "generate_venn_chart",
+    description: "Generate a Venn diagram to visualize the relationships between different sets, showing how they intersect and overlap, such as the commonalities and differences between various groups.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Venn Chart",
+        readOnlyHint: true,
+    },
+};
+exports.venn = {
+    schema,
+    tool,
+};

package/build/charts/violin.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const violin: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            value: z.ZodNumber;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            startAtZero: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisXTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisYTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/violin.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.violin = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const data = zod_1.z.object({
+    category: zod_1.z
+        .string()
+        .describe("Category of the data point, such as '分类一'."),
+    value: zod_1.z.number().describe("Value of the data point, such as 10."),
+    group: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional group for the data point, used for grouping in the violin chart."),
+});
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for violin chart, such as, [{ category: 'Category A', value: 10 }], when the data is grouped, the 'group' field is required, such as, [{ category: 'Category B', value: 20, group: 'Group A' }].")
+        .nonempty({ message: "Violin chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        startAtZero: base_1.StartAtZeroSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+    axisXTitle: base_1.AxisXTitleSchema,
+    axisYTitle: base_1.AxisYTitleSchema,
+};
+const tool = {
+    name: "generate_violin_chart",
+    description: "Generate a violin chart to show data for statistical summaries among different categories, such as, comparing the distribution of data points across categories.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Violin Chart",
+        readOnlyHint: true,
+    },
+};
+exports.violin = {
+    schema,
+    tool,
+};

package/build/charts/waterfall.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const waterfall: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            value: z.ZodOptional<z.ZodNumber>;
+            isIntermediateTotal: z.ZodOptional<z.ZodBoolean>;
+            isTotal: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+            palette: z.ZodOptional<z.ZodObject<{
+                positiveColor: z.ZodOptional<z.ZodString>;
+                negativeColor: z.ZodOptional<z.ZodString>;
+                totalColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisXTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisYTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};

package/build/charts/waterfall.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waterfall = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const data = zod_1.z
+    .object({
+    category: zod_1.z.string(),
+    value: zod_1.z.number().optional(),
+    isIntermediateTotal: zod_1.z.boolean().optional(),
+    isTotal: zod_1.z.boolean().optional(),
+})
+    .superRefine((item, ctx) => {
+    if (!item.isIntermediateTotal &&
+        !item.isTotal &&
+        item.value === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: "The 'value' field is required for data points that are not totals.",
+            path: ["value"],
+        });
+    }
+});
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for waterfall chart, it should be an array of objects. Each object must contain a `category` field. For regular items, a `value` field is also required. The `isIntermediateTotal` field marks intermediate subtotals, and the `isTotal` field marks the final total. For example, [{ category: 'Initial', value: 100 }, { category: 'Increase', value: 50 }, { category: 'Subtotal', isIntermediateTotal: true }, { category: 'Decrease', value: -30 }, { category: 'Total', isTotal: true }].")
+        .nonempty({ message: "Waterfall chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        texture: base_1.TextureSchema,
+        palette: zod_1.z
+            .object({
+            positiveColor: zod_1.z
+                .string()
+                .optional()
+                .describe("Color for positive values (increases). Default is '#FF4D4F'."),
+            negativeColor: zod_1.z
+                .string()
+                .optional()
+                .describe("Color for negative values (decreases). Default is '#2EBB59'."),
+            totalColor: zod_1.z
+                .string()
+                .optional()
+                .describe("Color for total and intermediate total bars. Default is '#1783FF'."),
+        })
+            .optional(),
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+    axisXTitle: base_1.AxisXTitleSchema,
+    axisYTitle: base_1.AxisYTitleSchema,
+};
+// Waterfall chart tool descriptor
+const tool = {
+    name: "generate_waterfall_chart",
+    description: "Generate a waterfall chart to visualize the cumulative effect of sequentially introduced positive or negative values, such as showing how an initial value is affected by a series of intermediate positive or negative values leading to a final result. Waterfall charts are ideal for financial analysis, budget tracking, profit and loss statements, and understanding the composition of changes over time or categories.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+    annotations: {
+        title: "Generate Waterfall Chart",
+        readOnlyHint: true,
+    },
+};
+exports.waterfall = {
+    schema,
+    tool,
+};

package/build/charts/word-cloud.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const wordCloud: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            value: z.ZodNumber;
+        }, z.core.$strip>>;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                rough: "rough";
+            }>>>;
+        }, z.core.$strip>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            academy: "academy";
+            dark: "dark";
+        }>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+            [x: string]: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+        }, z.core.$strip>>;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+        };
+    };
+};