@inflexa-ai/harness 0.42.2 → 0.43.0

package/dist/contracts/report-blocks.d.ts

@@ -15,8 +15,8 @@
  */
 import { z } from "zod";
 /**
- * The chart vocabulary. The first seven values name one plot form each. The last four are presets of a
- * scientific plot, and the renderer expands a preset into a composition.
+ * The chart vocabulary. The first eleven values name one plot form each. Each value after them is a preset:
+ * the canonical figure of one plot of a field, which the renderer derives from its own figure module.
  */
 declare const ChartTypeSchema: z.ZodEnum<{
     bar: "bar";
@@ -26,10 +26,26 @@ declare const ChartTypeSchema: z.ZodEnum<{
     box: "box";
     heatmap: "heatmap";
     pie: "pie";
+    violin: "violin";
+    "stacked-bar": "stacked-bar";
+    "normalized-bar": "normalized-bar";
+    radar: "radar";
     volcano: "volcano";
     manhattan: "manhattan";
     ma: "ma";
     km: "km";
+    pca: "pca";
+    embedding: "embedding";
+    dotplot: "dotplot";
+    forest: "forest";
+    roc: "roc";
+    qq: "qq";
+    gsea: "gsea";
+    oncoprint: "oncoprint";
+    lollipop: "lollipop";
+    upset: "upset";
+    sankey: "sankey";
+    locuszoom: "locuszoom";
 }>;
 /** The per-row transforms of a channel. Each derived value comes from one cell. */
 declare const ChartTransformSchema: z.ZodEnum<{
@@ -39,69 +55,357 @@ declare const ChartTransformSchema: z.ZodEnum<{
     rank: "rank";
 }>;
 /**
- * The threshold pair of a preset that classifies its rows.
+ * The thresholds of a preset that classifies its rows.
  *
  * One declaration moves the guide lines and the color split together. Thus the split always lands on the
- * drawn lines, and no second declaration can disagree with the first one.
+ * drawn lines, and no second declaration can disagree with the first one. A volcano reads the pair. An MA
+ * reads the significance cut against its `p` column alone, thus the chart block holds the effect cut to the
+ * volcano.
  */
 declare const ChartThresholdsSchema: z.ZodObject<{
     significance: z.ZodNumber;
-    effect: z.ZodNumber;
+    effect: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 /**
- * One visual channel: a column name, or a column with a per-row transform.
+ * One visual channel: a column name, or a column with a per-row transform and a category order.
  *
- * The object form carries a column and a transform, and it carries no value. Thus a channel can never
- * bring a data literal into the chart option.
+ * The object form carries column names and closed enum members, and it carries no value. Thus a channel can
+ * never bring a data literal into the chart option. The refine holds the order direction to a declared sort
+ * column, because a direction with nothing to sort by names a rule that nothing reads.
  */
 export declare const ChartChannelSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     column: z.ZodString;
-    transform: z.ZodEnum<{
+    transform: z.ZodOptional<z.ZodEnum<{
         log10: "log10";
         neg_log10: "neg_log10";
         abs: "abs";
         rank: "rank";
-    }>;
+    }>>;
+    orderBy: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
 }, z.core.$strict>]>;
 /** The mapping from a data column to a visual channel. Each channel is optional. */
 declare const ChartEncodingSchema: z.ZodObject<{
     x: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         column: z.ZodString;
-        transform: z.ZodEnum<{
+        transform: z.ZodOptional<z.ZodEnum<{
             log10: "log10";
             neg_log10: "neg_log10";
             abs: "abs";
             rank: "rank";
-        }>;
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
     }, z.core.$strict>]>>;
     y: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         column: z.ZodString;
-        transform: z.ZodEnum<{
+        transform: z.ZodOptional<z.ZodEnum<{
             log10: "log10";
             neg_log10: "neg_log10";
             abs: "abs";
             rank: "rank";
-        }>;
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
     }, z.core.$strict>]>>;
     group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         column: z.ZodString;
-        transform: z.ZodEnum<{
+        transform: z.ZodOptional<z.ZodEnum<{
             log10: "log10";
             neg_log10: "neg_log10";
             abs: "abs";
             rank: "rank";
-        }>;
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
     }, z.core.$strict>]>>;
     value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         column: z.ZodString;
-        transform: z.ZodEnum<{
+        transform: z.ZodOptional<z.ZodEnum<{
             log10: "log10";
             neg_log10: "neg_log10";
             abs: "abs";
             rank: "rank";
-        }>;
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
     }, z.core.$strict>]>>;
     label: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    shape: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    p: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    censor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    risk: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    hit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    metric: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
+    tracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * One statistic of a figure: a short name, and the one cell that gives its value.
+ *
+ * The value is an artifact reference and never a literal, thus a printed statistic is grounded exactly as a
+ * metric is.
+ */
+export declare const ChartStatisticSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        locator: z.ZodObject<{
+            column: z.ZodString;
+            rowFilter: z.ZodOptional<z.ZodObject<{
+                column: z.ZodString;
+                op: z.ZodLiteral<"eq">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            }, z.core.$strict>>;
+            row: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        assert: z.ZodOptional<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            tolerance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        run: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-value">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * The second table of a figure, and the four columns of it that the figure reads.
+ *
+ * The track binds a whole table exactly as the chart binding does, thus it resolves and it grounds the same
+ * way.
+ */
+export declare const ChartTrackSchema: z.ZodObject<{
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>;
+        columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            count: "count";
+            identifier: "identifier";
+            category: "category";
+            "p-value": "p-value";
+            effect: "effect";
+        }>>>;
+        columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        run: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-table">;
+    }, z.core.$strict>;
+    start: z.ZodString;
+    end: z.ZodString;
+    label: z.ZodString;
+    length: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * The tree of one category axis of a heatmap: an edge list, and the three columns of it that the figure reads.
+ *
+ * The tree binds a whole table exactly as the chart binding does, thus it resolves and it grounds the same way.
+ */
+export declare const ChartTreeSchema: z.ZodObject<{
+    binding: z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+        rowBound: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            count: z.ZodNumber;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>;
+        columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            count: "count";
+            identifier: "identifier";
+            category: "category";
+            "p-value": "p-value";
+            effect: "effect";
+        }>>>;
+        columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        run: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        hash: z.ZodString;
+        snapshot: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"artifact-table">;
+    }, z.core.$strict>;
+    parent: z.ZodString;
+    child: z.ZodString;
+    height: z.ZodString;
 }, z.core.$strict>;
 /**
  * One series of a composition: a plot form, its own channels, and an optional legend name.
@@ -121,41 +425,117 @@ export declare const ChartSeriesSchema: z.ZodObject<{
     encoding: z.ZodObject<{
         x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>;
         y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>;
         y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
-        label: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     name: z.ZodOptional<z.ZodString>;
     orientation: z.ZodOptional<z.ZodEnum<{
@@ -212,7 +592,10 @@ export declare const ChartAxesSchema: z.ZodObject<{
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-/** The full chart grammar: the series, the annotations, and the axes. Each series reads the one bound table. */
+/**
+ * The full chart grammar: the series, the annotations, the axes, and the facet. Each series reads the one
+ * bound table.
+ */
 export declare const ChartCompositionSchema: z.ZodObject<{
     series: z.ZodArray<z.ZodObject<{
         form: z.ZodEnum<{
@@ -225,41 +608,117 @@ export declare const ChartCompositionSchema: z.ZodObject<{
         encoding: z.ZodObject<{
             x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 column: z.ZodString;
-                transform: z.ZodEnum<{
+                transform: z.ZodOptional<z.ZodEnum<{
                     log10: "log10";
                     neg_log10: "neg_log10";
                     abs: "abs";
                     rank: "rank";
-                }>;
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
             }, z.core.$strict>]>;
             y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 column: z.ZodString;
-                transform: z.ZodEnum<{
+                transform: z.ZodOptional<z.ZodEnum<{
                     log10: "log10";
                     neg_log10: "neg_log10";
                     abs: "abs";
                     rank: "rank";
-                }>;
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
             }, z.core.$strict>]>;
             y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 column: z.ZodString;
-                transform: z.ZodEnum<{
+                transform: z.ZodOptional<z.ZodEnum<{
                     log10: "log10";
                     neg_log10: "neg_log10";
                     abs: "abs";
                     rank: "rank";
-                }>;
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
             }, z.core.$strict>]>>;
             group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 column: z.ZodString;
-                transform: z.ZodEnum<{
+                transform: z.ZodOptional<z.ZodEnum<{
                     log10: "log10";
                     neg_log10: "neg_log10";
                     abs: "abs";
                     rank: "rank";
-                }>;
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
             }, z.core.$strict>]>>;
             label: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodOptional<z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strict>]>>;
+            size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodOptional<z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strict>]>>;
+            low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodOptional<z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strict>]>>;
+            high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                column: z.ZodString;
+                transform: z.ZodOptional<z.ZodEnum<{
+                    log10: "log10";
+                    neg_log10: "neg_log10";
+                    abs: "abs";
+                    rank: "rank";
+                }>>;
+                orderBy: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strict>]>>;
         }, z.core.$strict>;
         name: z.ZodOptional<z.ZodString>;
         orientation: z.ZodOptional<z.ZodEnum<{
@@ -309,6 +768,20 @@ export declare const ChartCompositionSchema: z.ZodObject<{
             }>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        column: z.ZodString;
+        transform: z.ZodOptional<z.ZodEnum<{
+            log10: "log10";
+            neg_log10: "neg_log10";
+            abs: "abs";
+            rank: "rank";
+        }>>;
+        orderBy: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strict>]>>;
 }, z.core.$strict>;
 /**
  * One typed list of a text block: the flag that selects the form, and the items.
@@ -588,49 +1061,240 @@ export declare const ChartBlockSchema: z.ZodObject<{
         box: "box";
         heatmap: "heatmap";
         pie: "pie";
+        violin: "violin";
+        "stacked-bar": "stacked-bar";
+        "normalized-bar": "normalized-bar";
+        radar: "radar";
         volcano: "volcano";
         manhattan: "manhattan";
         ma: "ma";
         km: "km";
+        pca: "pca";
+        embedding: "embedding";
+        dotplot: "dotplot";
+        forest: "forest";
+        roc: "roc";
+        qq: "qq";
+        gsea: "gsea";
+        oncoprint: "oncoprint";
+        lollipop: "lollipop";
+        upset: "upset";
+        sankey: "sankey";
+        locuszoom: "locuszoom";
     }>>;
     encoding: z.ZodOptional<z.ZodObject<{
         x: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         y: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        shape: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        p: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        censor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        risk: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        hit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        metric: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        tracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     orientation: z.ZodOptional<z.ZodEnum<{
         vertical: "vertical";
@@ -638,7 +1302,7 @@ export declare const ChartBlockSchema: z.ZodObject<{
     }>>;
     thresholds: z.ZodOptional<z.ZodObject<{
         significance: z.ZodNumber;
-        effect: z.ZodNumber;
+        effect: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     composition: z.ZodOptional<z.ZodObject<{
         series: z.ZodArray<z.ZodObject<{
@@ -652,41 +1316,117 @@ export declare const ChartBlockSchema: z.ZodObject<{
             encoding: z.ZodObject<{
                 x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>;
                 y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>;
                 y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>>;
                 group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>>;
                 label: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
             }, z.core.$strict>;
             name: z.ZodOptional<z.ZodString>;
             orientation: z.ZodOptional<z.ZodEnum<{
@@ -728,13 +1468,149 @@ export declare const ChartBlockSchema: z.ZodObject<{
                     linear: "linear";
                 }>>;
             }, z.core.$strict>>;
-            y: z.ZodOptional<z.ZodObject<{
-                title: z.ZodOptional<z.ZodString>;
-                scale: z.ZodOptional<z.ZodEnum<{
-                    log: "log";
-                    linear: "linear";
+            y: z.ZodOptional<z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                scale: z.ZodOptional<z.ZodEnum<{
+                    log: "log";
+                    linear: "linear";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    focus: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    statistics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodString>;
+            locator: z.ZodObject<{
+                column: z.ZodString;
+                rowFilter: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    op: z.ZodLiteral<"eq">;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                }, z.core.$strict>>;
+                row: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            assert: z.ZodOptional<z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                tolerance: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            run: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-value">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    track: z.ZodOptional<z.ZodObject<{
+        binding: z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodString>;
+            rowBound: z.ZodOptional<z.ZodObject<{
+                column: z.ZodString;
+                count: z.ZodNumber;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
                 }>>;
             }, z.core.$strict>>;
+            columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                count: "count";
+                identifier: "identifier";
+                category: "category";
+                "p-value": "p-value";
+                effect: "effect";
+            }>>>;
+            columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            run: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-table">;
+        }, z.core.$strict>;
+        start: z.ZodString;
+        end: z.ZodString;
+        label: z.ZodString;
+        length: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    trees: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodObject<{
+            binding: z.ZodObject<{
+                unit: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodString>;
+                rowBound: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    count: z.ZodNumber;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>>;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    count: "count";
+                    identifier: "identifier";
+                    category: "category";
+                    "p-value": "p-value";
+                    effect: "effect";
+                }>>>;
+                columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                run: z.ZodOptional<z.ZodString>;
+                path: z.ZodString;
+                hash: z.ZodString;
+                snapshot: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"artifact-table">;
+            }, z.core.$strict>;
+            parent: z.ZodString;
+            child: z.ZodString;
+            height: z.ZodString;
+        }, z.core.$strict>>;
+        y: z.ZodOptional<z.ZodObject<{
+            binding: z.ZodObject<{
+                unit: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodString>;
+                rowBound: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    count: z.ZodNumber;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>>;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    count: "count";
+                    identifier: "identifier";
+                    category: "category";
+                    "p-value": "p-value";
+                    effect: "effect";
+                }>>>;
+                columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                run: z.ZodOptional<z.ZodString>;
+                path: z.ZodString;
+                hash: z.ZodString;
+                snapshot: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"artifact-table">;
+            }, z.core.$strict>;
+            parent: z.ZodString;
+            child: z.ZodString;
+            height: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     caption: z.ZodOptional<z.ZodString>;
@@ -1032,49 +1908,240 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
         box: "box";
         heatmap: "heatmap";
         pie: "pie";
+        violin: "violin";
+        "stacked-bar": "stacked-bar";
+        "normalized-bar": "normalized-bar";
+        radar: "radar";
         volcano: "volcano";
         manhattan: "manhattan";
         ma: "ma";
         km: "km";
+        pca: "pca";
+        embedding: "embedding";
+        dotplot: "dotplot";
+        forest: "forest";
+        roc: "roc";
+        qq: "qq";
+        gsea: "gsea";
+        oncoprint: "oncoprint";
+        lollipop: "lollipop";
+        upset: "upset";
+        sankey: "sankey";
+        locuszoom: "locuszoom";
     }>>;
     encoding: z.ZodOptional<z.ZodObject<{
         x: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         y: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             column: z.ZodString;
-            transform: z.ZodEnum<{
+            transform: z.ZodOptional<z.ZodEnum<{
                 log10: "log10";
                 neg_log10: "neg_log10";
                 abs: "abs";
                 rank: "rank";
-            }>;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
         }, z.core.$strict>]>>;
         label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        shape: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        p: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        censor: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        risk: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        hit: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        metric: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+        tracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     orientation: z.ZodOptional<z.ZodEnum<{
         vertical: "vertical";
@@ -1082,7 +2149,7 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
     }>>;
     thresholds: z.ZodOptional<z.ZodObject<{
         significance: z.ZodNumber;
-        effect: z.ZodNumber;
+        effect: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     composition: z.ZodOptional<z.ZodObject<{
         series: z.ZodArray<z.ZodObject<{
@@ -1096,41 +2163,117 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
             encoding: z.ZodObject<{
                 x: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>;
                 y: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>;
                 y0: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>>;
                 group: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                     column: z.ZodString;
-                    transform: z.ZodEnum<{
+                    transform: z.ZodOptional<z.ZodEnum<{
                         log10: "log10";
                         neg_log10: "neg_log10";
                         abs: "abs";
                         rank: "rank";
-                    }>;
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
                 }, z.core.$strict>]>>;
                 label: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                size: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                low: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
+                high: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    column: z.ZodString;
+                    transform: z.ZodOptional<z.ZodEnum<{
+                        log10: "log10";
+                        neg_log10: "neg_log10";
+                        abs: "abs";
+                        rank: "rank";
+                    }>>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>]>>;
             }, z.core.$strict>;
             name: z.ZodOptional<z.ZodString>;
             orientation: z.ZodOptional<z.ZodEnum<{
@@ -1180,6 +2323,142 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
                 }>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        facet: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            column: z.ZodString;
+            transform: z.ZodOptional<z.ZodEnum<{
+                log10: "log10";
+                neg_log10: "neg_log10";
+                abs: "abs";
+                rank: "rank";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    focus: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    statistics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodString>;
+            locator: z.ZodObject<{
+                column: z.ZodString;
+                rowFilter: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    op: z.ZodLiteral<"eq">;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                }, z.core.$strict>>;
+                row: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            assert: z.ZodOptional<z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                tolerance: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            run: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-value">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    track: z.ZodOptional<z.ZodObject<{
+        binding: z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodString>;
+            rowBound: z.ZodOptional<z.ZodObject<{
+                column: z.ZodString;
+                count: z.ZodNumber;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strict>>;
+            columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                count: "count";
+                identifier: "identifier";
+                category: "category";
+                "p-value": "p-value";
+                effect: "effect";
+            }>>>;
+            columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            run: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            hash: z.ZodString;
+            snapshot: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"artifact-table">;
+        }, z.core.$strict>;
+        start: z.ZodString;
+        end: z.ZodString;
+        label: z.ZodString;
+        length: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    trees: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodObject<{
+            binding: z.ZodObject<{
+                unit: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodString>;
+                rowBound: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    count: z.ZodNumber;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>>;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    count: "count";
+                    identifier: "identifier";
+                    category: "category";
+                    "p-value": "p-value";
+                    effect: "effect";
+                }>>>;
+                columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                run: z.ZodOptional<z.ZodString>;
+                path: z.ZodString;
+                hash: z.ZodString;
+                snapshot: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"artifact-table">;
+            }, z.core.$strict>;
+            parent: z.ZodString;
+            child: z.ZodString;
+            height: z.ZodString;
+        }, z.core.$strict>>;
+        y: z.ZodOptional<z.ZodObject<{
+            binding: z.ZodObject<{
+                unit: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodString>;
+                rowBound: z.ZodOptional<z.ZodObject<{
+                    column: z.ZodString;
+                    count: z.ZodNumber;
+                    order: z.ZodOptional<z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, z.core.$strict>>;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                columnMeanings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    count: "count";
+                    identifier: "identifier";
+                    category: "category";
+                    "p-value": "p-value";
+                    effect: "effect";
+                }>>>;
+                columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                run: z.ZodOptional<z.ZodString>;
+                path: z.ZodString;
+                hash: z.ZodString;
+                snapshot: z.ZodOptional<z.ZodString>;
+                kind: z.ZodLiteral<"artifact-table">;
+            }, z.core.$strict>;
+            parent: z.ZodString;
+            child: z.ZodString;
+            height: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     caption: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
@@ -1267,6 +2546,13 @@ export declare const ReportDocumentSchema: z.ZodObject<{
 export declare function channelColumn(channel: ChartChannel): string;
 /** The transform of one channel, or `undefined` when the channel names a plain column. */
 export declare function channelTransform(channel: ChartChannel): ChartTransform | undefined;
+/** The category order of one channel: the column that sorts the categories, and the direction of the sort. */
+export interface ChannelOrder {
+    readonly by: string;
+    readonly order: "asc" | "desc";
+}
+/** The category order of one channel, or `undefined` when the channel declares none. */
+export declare function channelOrder(channel: ChartChannel): ChannelOrder | undefined;
 export type ChartChannel = z.infer<typeof ChartChannelSchema>;
 export type ChartTransform = z.infer<typeof ChartTransformSchema>;
 export type ChartEncoding = z.infer<typeof ChartEncodingSchema>;
@@ -1275,6 +2561,9 @@ export type ChartAnnotation = z.infer<typeof ChartAnnotationSchema>;
 export type ChartAxes = z.infer<typeof ChartAxesSchema>;
 export type ChartThresholds = z.infer<typeof ChartThresholdsSchema>;
 export type ChartComposition = z.infer<typeof ChartCompositionSchema>;
+export type ChartStatistic = z.infer<typeof ChartStatisticSchema>;
+export type ChartTrack = z.infer<typeof ChartTrackSchema>;
+export type ChartTree = z.infer<typeof ChartTreeSchema>;
 export type ChartType = z.infer<typeof ChartTypeSchema>;
 export type TextList = z.infer<typeof TextListSchema>;
 export type TextBlock = z.infer<typeof TextBlockSchema>;