npm - mulmocast - Versions diffs - 2.6.3 → 2.6.4 - Mend

mulmocast 2.6.3 → 2.6.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/README.md +2 -1
package/assets/html/chart.html +40 -7
package/lib/actions/image_agents.d.ts +6 -0
package/lib/actions/image_agents.js +28 -2
package/lib/actions/images.d.ts +26 -0
package/lib/actions/images.js +2 -0
package/lib/agents/movie_genai_agent.js +36 -6
package/lib/agents/movie_replicate_agent.js +20 -3
package/lib/methods/mulmo_presentation_style.d.ts +6 -0
package/lib/slide/layouts/index.js +3 -0
package/lib/slide/layouts/waterfall.d.ts +2 -0
package/lib/slide/layouts/waterfall.js +63 -0
package/lib/slide/render.js +4 -1
package/lib/slide/schema.d.ts +176 -0
package/lib/slide/schema.js +18 -0
package/lib/slide/utils.d.ts +1 -0
package/lib/slide/utils.js +21 -1
package/lib/types/agent.d.ts +6 -0
package/lib/types/provider2agent.d.ts +6 -11
package/lib/types/provider2agent.js +10 -0
package/lib/types/schema.d.ts +400 -0
package/lib/types/schema.js +12 -0
package/lib/types/slide.d.ts +176 -0
package/lib/types/slide.js +18 -0
package/lib/utils/context.d.ts +112 -0
package/lib/utils/html_render.js +4 -3
package/lib/utils/image_plugins/chart.js +19 -6
package/lib/utils/image_plugins/mermaid.js +5 -1
package/package.json +1 -1
package/scripts/test/test_ir_visualizations.json +317 -0
package/scripts/test/test_movie_references.json +101 -0
package/scripts/test/test_plugin_features.json +151 -0

package/README.md CHANGED Viewed

@@ -396,8 +396,9 @@ MulmoCast includes a powerful **Slide DSL** (`type: "slide"`) for creating struc
 ### Features
-- **11 Layouts**: title, columns, comparison, grid, bigQuote, stats, timeline, split, matrix, table, funnel
+- **12 Layouts**: title, columns, comparison, grid, bigQuote, stats, timeline, split, matrix, table, funnel, waterfall
 - **10 Content Block Types**: text, bullets, code, callout, metric, divider, image, imageRef, chart, mermaid
+- **Chart.js Plugins**: sankey (`chartjs-chart-sankey`) and treemap (`chartjs-chart-treemap`) auto-loaded by chart type
 - **13-Color Theme System**: Semantic color palette with dark/light support
 - **6 Preset Themes**: dark, pop, warm, creative, minimal, corporate

package/assets/html/chart.html CHANGED Viewed

@@ -5,14 +5,18 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Simple Chart.js Bar Chart</title>
     <style>
+        html, body { height: 100%; margin: 0; }
+        body { display: flex; flex-direction: column; align-items: center; justify-content: center; }
         ${style}
         .chart-container {
             width: ${chart_width}px;
-            margin: 0 auto;
+            height: 70vh;
+            position: relative;
         }
     </style>
     <!-- Include Chart.js from CDN -->
-    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4"></script>
+    ${chart_plugins}
 </head>
 <body>
     <h1>${title}</h1>
@@ -20,9 +24,7 @@
         <canvas id="myChart" data-chart-ready="false"></canvas>
     </div>
-    <!-- Plain JavaScript instead of TypeScript -->
     <script>
-        // Wait for DOM and Chart.js to be ready, then render.
         function initChart() {
             if (!window.Chart) return false;
             const ctx = document.getElementById('myChart');
@@ -32,10 +34,41 @@
             // Disable animation for static image generation
             if (!chartData.options) chartData.options = {};
             chartData.options.animation = false;
+            chartData.options.responsive = true;
+            chartData.options.maintainAspectRatio = false;
-            // Initialize the chart
+            // Treemap: convert backgroundColor array to scriptable function
+            if (chartData.type === 'treemap') {
+                chartData.data.datasets.forEach((ds) => {
+                    if (Array.isArray(ds.backgroundColor)) {
+                        const colors = ds.backgroundColor;
+                        ds.backgroundColor = (c) => colors[c.dataIndex % colors.length];
+                    }
+                });
+            }
+            // Sankey: convert colorFrom/colorTo objects to lookup functions
+            if (chartData.type === 'sankey') {
+                chartData.data.datasets.forEach((ds) => {
+                    if (ds.colorFrom && typeof ds.colorFrom === 'object') {
+                        const fromMap = ds.colorFrom;
+                        ds.colorFrom = (c) => fromMap[c.dataset.data[c.dataIndex].from] || '#999';
+                    }
+                    if (ds.colorTo && typeof ds.colorTo === 'object') {
+                        const toMap = ds.colorTo;
+                        ds.colorTo = (c) => toMap[c.dataset.data[c.dataIndex].to] || '#999';
+                    }
+                });
+            }
+            try {
+                const chart = new Chart(ctx, chartData);
+                chart.resize();
+                chart.update();
+            } catch (e) {
+                console.error('Chart init error:', e);
+            }
-            new Chart(ctx, chartData);
             requestAnimationFrame(() => {
                 requestAnimationFrame(() => {
                     ctx.dataset.chartReady = "true";
@@ -49,7 +82,7 @@
             setTimeout(waitForChart, 50);
         }
-        document.addEventListener('DOMContentLoaded', function() {
+        document.addEventListener('DOMContentLoaded', () => {
             waitForChart();
         });
     </script>

package/lib/actions/image_agents.d.ts CHANGED Viewed

@@ -22,6 +22,12 @@ type ImagePreprocessAgentReturnValue = {
         agent: string;
         movieParams: MulmoMovieParams;
     };
+    firstFrameImagePath?: string;
+    lastFrameImagePath?: string;
+    movieReferenceImages?: {
+        imagePath: string;
+        referenceType: "ASSET" | "STYLE";
+    }[];
 };
 type ImagePreprocessAgentResponseBase = ImagePreprocessAgentReturnValue & {
     imagePath?: string;

package/lib/actions/image_agents.js CHANGED Viewed

@@ -66,6 +66,28 @@ export const imagePreprocessAgent = async (namedInputs) => {
         }
     }
     returnValue.movieAgentInfo = MulmoPresentationStyleMethods.getMovieAgentInfo(context.presentationStyle, beat);
+    // Resolve movie reference images from imageRefs
+    const movieParams = beat.movieParams ?? context.presentationStyle.movieParams;
+    if (movieParams?.firstFrameImageName && imageRefs) {
+        const firstFramePath = imageRefs[movieParams.firstFrameImageName];
+        if (firstFramePath) {
+            returnValue.firstFrameImagePath = firstFramePath;
+        }
+    }
+    if (movieParams?.lastFrameImageName && imageRefs) {
+        const lastFramePath = imageRefs[movieParams.lastFrameImageName];
+        if (lastFramePath) {
+            returnValue.lastFrameImagePath = lastFramePath;
+        }
+    }
+    if (movieParams?.referenceImages && imageRefs) {
+        returnValue.movieReferenceImages = movieParams.referenceImages
+            .map((ref) => {
+            const refPath = imageRefs[ref.imageName];
+            return refPath ? { imagePath: refPath, referenceType: ref.referenceType } : undefined;
+        })
+            .filter((r) => r !== undefined);
+    }
     if (beat.image) {
         const plugin = MulmoBeatMethods.getPlugin(beat);
         const pluginPath = plugin.path({ beat, context, imagePath, ...htmlStyle(context, beat) });
@@ -106,13 +128,17 @@ export const imagePreprocessAgent = async (namedInputs) => {
     }
     if (beat.moviePrompt && !beat.imagePrompt) {
         // ImageOnlyMoviePreprocessAgentResponse
-        return { ...returnValue, imagePath, imageFromMovie: true }; // no image prompt, only movie prompt
+        // If firstFrameImageName is specified, use the resolved ref image as the movie's first frame
+        const base = { ...returnValue, imagePath, imageFromMovie: true };
+        return returnValue.firstFrameImagePath ? { ...base, referenceImageForMovie: returnValue.firstFrameImagePath } : base;
     }
     // referenceImages for "edit_image", openai agent.
     const referenceImages = MulmoBeatMethods.getImageReferenceForImageGenerator(beat, imageRefs ?? {});
     const prompt = imagePrompt(beat, imageAgentInfo.imageParams.style);
     // ImageGenearalPreprocessAgentResponse
-    return { ...returnValue, imagePath, referenceImageForMovie: imagePath, imageAgentInfo, prompt, referenceImages };
+    // firstFrameImagePath (from movieParams.firstFrameImageName) takes precedence over generated image
+    const movieFirstFramePath = returnValue.firstFrameImagePath ?? imagePath;
+    return { ...returnValue, imagePath, referenceImageForMovie: movieFirstFramePath, imageAgentInfo, prompt, referenceImages };
 };
 export const imagePluginAgent = async (namedInputs) => {
     const { context, beat, index, imageRefs, movieRefs } = namedInputs;

package/lib/actions/images.d.ts CHANGED Viewed

@@ -70,6 +70,12 @@ export declare const beat_graph_data: {
                     agent: string;
                     movieParams: import("../types/type.js").MulmoMovieParams;
                 };
+                firstFrameImagePath?: string;
+                lastFrameImagePath?: string;
+                movieReferenceImages?: {
+                    imagePath: string;
+                    referenceType: "ASSET" | "STYLE";
+                }[];
             } & {
                 imagePath?: string;
             }) | ({
@@ -95,6 +101,12 @@ export declare const beat_graph_data: {
                     agent: string;
                     movieParams: import("../types/type.js").MulmoMovieParams;
                 };
+                firstFrameImagePath?: string;
+                lastFrameImagePath?: string;
+                movieReferenceImages?: {
+                    imagePath: string;
+                    referenceType: "ASSET" | "STYLE";
+                }[];
             } & {
                 imagePath?: string;
             } & {
@@ -131,6 +143,12 @@ export declare const beat_graph_data: {
                     agent: string;
                     movieParams: import("../types/type.js").MulmoMovieParams;
                 };
+                firstFrameImagePath?: string;
+                lastFrameImagePath?: string;
+                movieReferenceImages?: {
+                    imagePath: string;
+                    referenceType: "ASSET" | "STYLE";
+                }[];
             } & {
                 imagePath?: string;
             } & {
@@ -159,6 +177,12 @@ export declare const beat_graph_data: {
                     agent: string;
                     movieParams: import("../types/type.js").MulmoMovieParams;
                 };
+                firstFrameImagePath?: string;
+                lastFrameImagePath?: string;
+                movieReferenceImages?: {
+                    imagePath: string;
+                    referenceType: "ASSET" | "STYLE";
+                }[];
             } & {
                 imagePath?: string;
             } & {
@@ -282,6 +306,8 @@ export declare const beat_graph_data: {
                 onComplete: string[];
                 prompt: string;
                 imagePath: string;
+                lastFrameImagePath: string;
+                referenceImages: string;
                 movieFile: string;
                 cache: {
                     force: string[];

package/lib/actions/images.js CHANGED Viewed

@@ -177,6 +177,8 @@ export const beat_graph_data = {
                 onComplete: [":imageGenerator", ":imagePlugin"], // to wait for imageGenerator to finish
                 prompt: ":beat.moviePrompt",
                 imagePath: ":preprocessor.referenceImageForMovie",
+                lastFrameImagePath: ":preprocessor.lastFrameImagePath",
+                referenceImages: ":preprocessor.movieReferenceImages",
                 movieFile: ":preprocessor.movieFile", // for google genai agent
                 cache: {
                     force: [":context.force", ":forceMovie"],

package/lib/agents/movie_genai_agent.js CHANGED Viewed

@@ -94,25 +94,55 @@ const generateExtendedVideo = async (ai, model, prompt, aspectRatio, imagePath,
     }
     return downloadVideo(ai, result.video, movieFile, isVertexAI);
 };
-const generateStandardVideo = async (ai, model, prompt, aspectRatio, imagePath, duration, movieFile, isVertexAI) => {
-    const isVeo3 = model === "veo-3.0-generate-001" || model === "veo-3.1-generate-preview";
+const generateStandardVideo = async (ai, model, prompt, aspectRatio, imagePath, lastFrameImagePath, referenceImages, duration, movieFile, isVertexAI) => {
+    const capabilities = provider2MovieAgent.google.modelParams[model];
     const payload = {
         model,
         prompt,
         config: {
-            durationSeconds: isVeo3 ? undefined : duration,
+            durationSeconds: capabilities?.supportsPersonGeneration === false ? undefined : duration,
             aspectRatio,
-            personGeneration: imagePath ? undefined : PersonGeneration.ALLOW_ALL,
+            personGeneration: imagePath || !capabilities?.supportsPersonGeneration ? undefined : PersonGeneration.ALLOW_ALL,
         },
         image: imagePath ? loadImageAsBase64(imagePath) : undefined,
     };
+    // Validate and apply lastFrame
+    if (lastFrameImagePath) {
+        if (!capabilities?.supportsLastFrame) {
+            GraphAILogger.warn(`movieGenAIAgent: model ${model} does not support lastFrame — ignoring lastFrameImageName`);
+        }
+        else if (!imagePath) {
+            GraphAILogger.warn(`movieGenAIAgent: lastFrame requires a first frame image (imagePrompt or firstFrameImageName) — ignoring lastFrameImageName`);
+        }
+        else {
+            payload.config.lastFrame = loadImageAsBase64(lastFrameImagePath);
+        }
+    }
+    // Validate and apply referenceImages (mutually exclusive with image/lastFrame)
+    if (referenceImages && referenceImages.length > 0) {
+        if (!capabilities?.supportsReferenceImages) {
+            GraphAILogger.warn(`movieGenAIAgent: model ${model} does not support referenceImages — ignoring`);
+        }
+        else if (imagePath) {
+            GraphAILogger.warn(`movieGenAIAgent: referenceImages cannot be combined with first frame image — ignoring referenceImages`);
+        }
+        else if (lastFrameImagePath) {
+            GraphAILogger.warn(`movieGenAIAgent: referenceImages cannot be combined with lastFrame — ignoring referenceImages`);
+        }
+        else {
+            payload.config.referenceImages = referenceImages.map((ref) => ({
+                image: loadImageAsBase64(ref.imagePath),
+                referenceType: ref.referenceType,
+            }));
+        }
+    }
     const operation = await ai.models.generateVideos(payload);
     const response = await pollUntilDone(ai, operation);
     const video = getVideoFromResponse(response);
     return downloadVideo(ai, video, movieFile, isVertexAI);
 };
 export const movieGenAIAgent = async ({ namedInputs, params, config, }) => {
-    const { prompt, imagePath, movieFile } = namedInputs;
+    const { prompt, imagePath, lastFrameImagePath, referenceImages, movieFile } = namedInputs;
     const aspectRatio = getAspectRatio(params.canvasSize, ASPECT_RATIOS);
     const model = params.model ?? provider2MovieAgent.google.defaultModel;
     const apiKey = config?.apiKey;
@@ -144,7 +174,7 @@ export const movieGenAIAgent = async ({ namedInputs, params, config, }) => {
             return generateExtendedVideo(ai, model, prompt, aspectRatio, imagePath, requestedDuration, movieFile, isVertexAI);
         }
         // Standard mode
-        return generateStandardVideo(ai, model, prompt, aspectRatio, imagePath, duration, movieFile, isVertexAI);
+        return generateStandardVideo(ai, model, prompt, aspectRatio, imagePath, lastFrameImagePath, referenceImages, duration, movieFile, isVertexAI);
     }
     catch (error) {
         GraphAILogger.info("Failed to generate movie:", error.message);

package/lib/agents/movie_replicate_agent.js CHANGED Viewed

@@ -3,7 +3,7 @@ import { GraphAILogger } from "graphai";
 import Replicate from "replicate";
 import { apiKeyMissingError, agentGenerationError, agentInvalidResponseError, imageAction, movieFileTarget, videoDurationTarget, unsupportedModelTarget, } from "../utils/error_cause.js";
 import { provider2MovieAgent, getModelDuration } from "../types/provider2agent.js";
-async function generateMovie(model, apiKey, prompt, imagePath, aspectRatio, duration) {
+async function generateMovie(model, apiKey, prompt, imagePath, lastFrameImagePath, aspectRatio, duration) {
     const replicate = new Replicate({
         auth: apiKey,
     });
@@ -37,6 +37,23 @@ async function generateMovie(model, apiKey, prompt, imagePath, aspectRatio, dura
             input.image = base64Image;
         }
     }
+    // Add last frame image if provided and model supports it
+    if (lastFrameImagePath) {
+        const lastImageParam = provider2MovieAgent.replicate.modelParams[model]?.last_image;
+        if (lastImageParam) {
+            if (!imagePath) {
+                GraphAILogger.warn(`movieReplicateAgent: model ${model} requires a first frame image to use lastFrame — ignoring lastFrameImageName`);
+            }
+            else {
+                const buffer = readFileSync(lastFrameImagePath);
+                const base64Image = `data:image/png;base64,${buffer.toString("base64")}`;
+                input[lastImageParam] = base64Image;
+            }
+        }
+        else {
+            GraphAILogger.warn(`movieReplicateAgent: model ${model} does not support lastFrame — ignoring lastFrameImageName`);
+        }
+    }
     try {
         const output = await replicate.run(model, { input });
         // Download the generated video
@@ -72,7 +89,7 @@ export const getAspectRatio = (canvasSize) => {
     return "9:16";
 };
 export const movieReplicateAgent = async ({ namedInputs, params, config, }) => {
-    const { prompt, imagePath } = namedInputs;
+    const { prompt, imagePath, lastFrameImagePath } = namedInputs;
     const aspectRatio = getAspectRatio(params.canvasSize);
     const model = params.model ?? provider2MovieAgent.replicate.defaultModel;
     if (!provider2MovieAgent.replicate.modelParams[model]) {
@@ -93,7 +110,7 @@ export const movieReplicateAgent = async ({ namedInputs, params, config, }) => {
         });
     }
     try {
-        const buffer = await generateMovie(model, apiKey, prompt, imagePath, aspectRatio, duration);
+        const buffer = await generateMovie(model, apiKey, prompt, imagePath, lastFrameImagePath, aspectRatio, duration);
         if (buffer) {
             return { buffer };
         }

package/lib/methods/mulmo_presentation_style.d.ts CHANGED Viewed

@@ -173,6 +173,12 @@ export declare const MulmoPresentationStyleMethods: {
             })[] | undefined;
             vertexai_project?: string | undefined;
             vertexai_location?: string | undefined;
+            firstFrameImageName?: string | undefined;
+            lastFrameImageName?: string | undefined;
+            referenceImages?: {
+                imageName: string;
+                referenceType: "ASSET" | "STYLE";
+            }[] | undefined;
             speed?: number | undefined;
         };
         keyName: string;

package/lib/slide/layouts/index.js CHANGED Viewed

@@ -9,6 +9,7 @@ import { layoutSplit } from "./split.js";
 import { layoutMatrix } from "./matrix.js";
 import { layoutTable } from "./table.js";
 import { layoutFunnel } from "./funnel.js";
+import { layoutWaterfall } from "./waterfall.js";
 import { escapeHtml } from "../utils.js";
 /** Render the inner content of a slide (without the wrapper div) */
 export const renderSlideContent = (slide) => {
@@ -35,6 +36,8 @@ export const renderSlideContent = (slide) => {
             return layoutTable(slide);
         case "funnel":
             return layoutFunnel(slide);
+        case "waterfall":
+            return layoutWaterfall(slide);
         default: {
             const _exhaustive = slide;
             return `<p class="text-white p-8">Unknown layout: ${escapeHtml(String(_exhaustive.layout))}</p>`;

package/lib/slide/layouts/waterfall.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { WaterfallSlide } from "../schema.js";
2	+ export declare const layoutWaterfall: (data: WaterfallSlide) => string;

package/lib/slide/layouts/waterfall.js ADDED Viewed

@@ -0,0 +1,63 @@
+import { renderInlineMarkup, c, slideHeader, renderOptionalCallout } from "../utils.js";
+/** Height of the chart area as percentage of available space */
+const CHART_HEIGHT_PCT = 75;
+export const layoutWaterfall = (data) => {
+    const parts = [slideHeader(data)];
+    const items = data.items || [];
+    const positions = buildWaterfallPositions(items);
+    const globalMax = Math.max(...positions.map((p) => p.top));
+    const globalMin = Math.min(...positions.map((p) => p.bottom));
+    const range = globalMax - globalMin || 1;
+    parts.push(`<div class="flex gap-1 px-12 mt-4 flex-1" style="min-height: 0">`);
+    items.forEach((item, i) => {
+        const pos = positions[i];
+        const isTotal = item.isTotal ?? false;
+        const isPositive = item.value >= 0;
+        const color = resolveBarColor(item.color, isTotal, isPositive);
+        const bottomPct = ((pos.bottom - globalMin) / range) * CHART_HEIGHT_PCT;
+        const heightPct = Math.max(((pos.top - pos.bottom) / range) * CHART_HEIGHT_PCT, 1.5);
+        const topOfBar = bottomPct + heightPct;
+        const labelTopPct = 100 - topOfBar;
+        const formattedValue = formatValue(item.value, data.unit, isTotal);
+        parts.push(`<div class="flex-1 relative" style="height: 100%">`);
+        // Value label (above bar)
+        parts.push(`  <p class="absolute w-full text-xs font-bold text-d-text font-body text-center" style="top: ${labelTopPct - 4}%">${renderInlineMarkup(formattedValue)}</p>`);
+        // Bar (absolute positioned from bottom)
+        parts.push(`  <div class="absolute left-1 right-1 bg-${c(color)} rounded-t" style="bottom: ${bottomPct}%; height: ${heightPct}%"></div>`);
+        // Bottom label
+        parts.push(`  <p class="absolute bottom-0 w-full text-xs text-d-muted font-body text-center" style="transform: translateY(100%)">${renderInlineMarkup(item.label)}</p>`);
+        parts.push(`</div>`);
+    });
+    parts.push(`</div>`);
+    // Labels area
+    parts.push(`<div class="h-10 shrink-0"></div>`);
+    parts.push(renderOptionalCallout(data.callout));
+    return parts.join("\n");
+};
+const buildWaterfallPositions = (items) => {
+    let runningTotal = 0;
+    return items.map((item) => {
+        if (item.isTotal) {
+            runningTotal = item.value;
+            return { top: Math.max(item.value, 0), bottom: Math.min(item.value, 0) };
+        }
+        const prevTotal = runningTotal;
+        runningTotal += item.value;
+        if (item.value >= 0) {
+            return { top: runningTotal, bottom: prevTotal };
+        }
+        return { top: prevTotal, bottom: runningTotal };
+    });
+};
+const resolveBarColor = (itemColor, isTotal, isPositive) => {
+    if (itemColor)
+        return itemColor;
+    if (isTotal)
+        return "primary";
+    return isPositive ? "success" : "danger";
+};
+const formatValue = (value, unit, isTotal) => {
+    const prefix = !isTotal && value > 0 ? "+" : "";
+    const suffix = unit ? ` ${unit}` : "";
+    return `${prefix}${value}${suffix}`;
+};

package/lib/slide/render.js CHANGED Viewed

@@ -9,10 +9,13 @@ const isDarkBg = (hex) => {
 };
 /** Build CDN script tags for chart/mermaid when needed */
 const buildCdnScripts = (theme, slide) => {
-    const { hasChart, hasMermaid } = detectBlockTypes(slide);
+    const { hasChart, hasMermaid, chartPlugins } = detectBlockTypes(slide);
     const scripts = [];
     if (hasChart) {
         scripts.push('<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>');
+        chartPlugins.forEach((cdn) => {
+            scripts.push(`<script src="${cdn}"></script>`);
+        });
     }
     if (hasMermaid) {
         const mermaidTheme = isDarkBg(theme.colors.bg) ? "dark" : "default";

package/lib/slide/schema.d.ts CHANGED Viewed

@@ -4284,6 +4284,74 @@ export declare const tableSlideSchema: z.ZodObject<{
     }, z.core.$strip>>;
     layout: z.ZodLiteral<"table">;
 }, z.core.$strip>;
+export declare const waterfallItemSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodNumber;
+    isTotal: z.ZodOptional<z.ZodBoolean>;
+    color: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        primary: "primary";
+        accent: "accent";
+        warning: "warning";
+        danger: "danger";
+        info: "info";
+        highlight: "highlight";
+    }>>;
+}, z.core.$strip>;
+export declare const waterfallSlideSchema: z.ZodObject<{
+    title: z.ZodString;
+    stepLabel: z.ZodOptional<z.ZodString>;
+    subtitle: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        isTotal: z.ZodOptional<z.ZodBoolean>;
+        color: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            primary: "primary";
+            accent: "accent";
+            warning: "warning";
+            danger: "danger";
+            info: "info";
+            highlight: "highlight";
+        }>>;
+    }, z.core.$strip>>;
+    unit: z.ZodOptional<z.ZodString>;
+    callout: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            primary: "primary";
+            accent: "accent";
+            warning: "warning";
+            danger: "danger";
+            info: "info";
+            highlight: "highlight";
+        }>>;
+        align: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            center: "center";
+        }>>;
+        leftBar: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    accentColor: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        primary: "primary";
+        accent: "accent";
+        warning: "warning";
+        danger: "danger";
+        info: "info";
+        highlight: "highlight";
+    }>>;
+    style: z.ZodOptional<z.ZodObject<{
+        bgColor: z.ZodOptional<z.ZodString>;
+        decorations: z.ZodOptional<z.ZodBoolean>;
+        bgOpacity: z.ZodOptional<z.ZodNumber>;
+        footer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    layout: z.ZodLiteral<"waterfall">;
+}, z.core.$strip>;
 export declare const funnelStageSchema: z.ZodObject<{
     label: z.ZodString;
     value: z.ZodOptional<z.ZodString>;
@@ -6714,6 +6782,59 @@ export declare const slideLayoutSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         footer: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     layout: z.ZodLiteral<"funnel">;
+}, z.core.$strip>, z.ZodObject<{
+    title: z.ZodString;
+    stepLabel: z.ZodOptional<z.ZodString>;
+    subtitle: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        isTotal: z.ZodOptional<z.ZodBoolean>;
+        color: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            primary: "primary";
+            accent: "accent";
+            warning: "warning";
+            danger: "danger";
+            info: "info";
+            highlight: "highlight";
+        }>>;
+    }, z.core.$strip>>;
+    unit: z.ZodOptional<z.ZodString>;
+    callout: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            primary: "primary";
+            accent: "accent";
+            warning: "warning";
+            danger: "danger";
+            info: "info";
+            highlight: "highlight";
+        }>>;
+        align: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            center: "center";
+        }>>;
+        leftBar: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    accentColor: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        primary: "primary";
+        accent: "accent";
+        warning: "warning";
+        danger: "danger";
+        info: "info";
+        highlight: "highlight";
+    }>>;
+    style: z.ZodOptional<z.ZodObject<{
+        bgColor: z.ZodOptional<z.ZodString>;
+        decorations: z.ZodOptional<z.ZodBoolean>;
+        bgOpacity: z.ZodOptional<z.ZodNumber>;
+        footer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    layout: z.ZodLiteral<"waterfall">;
 }, z.core.$strip>], "layout">;
 /** Media schema registered in mulmoImageAssetSchema */
 export declare const mulmoSlideMediaSchema: z.ZodObject<{
@@ -9043,6 +9164,59 @@ export declare const mulmoSlideMediaSchema: z.ZodObject<{
             footer: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         layout: z.ZodLiteral<"funnel">;
+    }, z.core.$strip>, z.ZodObject<{
+        title: z.ZodString;
+        stepLabel: z.ZodOptional<z.ZodString>;
+        subtitle: z.ZodOptional<z.ZodString>;
+        items: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            isTotal: z.ZodOptional<z.ZodBoolean>;
+            color: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                primary: "primary";
+                accent: "accent";
+                warning: "warning";
+                danger: "danger";
+                info: "info";
+                highlight: "highlight";
+            }>>;
+        }, z.core.$strip>>;
+        unit: z.ZodOptional<z.ZodString>;
+        callout: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                primary: "primary";
+                accent: "accent";
+                warning: "warning";
+                danger: "danger";
+                info: "info";
+                highlight: "highlight";
+            }>>;
+            align: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                center: "center";
+            }>>;
+            leftBar: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        accentColor: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            primary: "primary";
+            accent: "accent";
+            warning: "warning";
+            danger: "danger";
+            info: "info";
+            highlight: "highlight";
+        }>>;
+        style: z.ZodOptional<z.ZodObject<{
+            bgColor: z.ZodOptional<z.ZodString>;
+            decorations: z.ZodOptional<z.ZodBoolean>;
+            bgOpacity: z.ZodOptional<z.ZodNumber>;
+            footer: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        layout: z.ZodLiteral<"waterfall">;
     }, z.core.$strip>], "layout">;
     reference: z.ZodOptional<z.ZodString>;
     branding: z.ZodOptional<z.ZodNullable<z.ZodObject<{
@@ -9128,6 +9302,8 @@ export type TableCellValue = z.infer<typeof tableCellValueSchema>;
 export type TableSlide = z.infer<typeof tableSlideSchema>;
 export type FunnelStage = z.infer<typeof funnelStageSchema>;
 export type FunnelSlide = z.infer<typeof funnelSlideSchema>;
+export type WaterfallItem = z.infer<typeof waterfallItemSchema>;
+export type WaterfallSlide = z.infer<typeof waterfallSlideSchema>;
 export type SlideBrandingLogo = z.infer<typeof slideBrandingLogoSchema>;
 export type SlideBranding = z.infer<typeof slideBrandingSchema>;
 export type MulmoSlideMedia = z.infer<typeof mulmoSlideMediaSchema>;