ggaction 0.0.12 → 0.0.15

package/types/program.d.ts

@@ -1,5 +1,34 @@
 import type { RegisteredExtensionActions } from "./extension.js";
 
+export type TemporalInputUnit = "auto" | "year" | "timestamp";
+export type ThemeName = "light" | "dark";
+export interface ThemeTokens {
+  background: string;
+  mark: string;
+  text: string;
+  strongText: string;
+  mutedText: string;
+  axis: string;
+  axisTitle: string;
+  grid: string;
+  border: string;
+  sizeSymbol: string;
+  regressionBand: string;
+  boxLine: string;
+  boxMedian: string;
+  referenceLine: string;
+  referenceBand: string;
+  gradientCenter: string;
+  highlight: string;
+  fontFamily: string;
+}
+export type ThemeDefinition =
+  | ThemeName
+  | { base: ThemeName; tokens: Partial<ThemeTokens> };
+export interface ApplyThemeOptions {
+  theme: ThemeDefinition;
+  scope?: "self" | "descendants";
+}
 export type FieldType = "quantitative" | "temporal" | "ordinal" | "nominal";
 export type GraphicType =
   | "canvas"
@@ -41,6 +70,7 @@ export interface LinearGradientPaint {
   ];
 }
 export type FillPaint = string | LinearGradientPaint;
+type FilledMarkStroke = string | false;
 export type CurveInterpolation =
   | "linear"
   | "step"
@@ -65,6 +95,20 @@ export interface JitterPointsOptions {
 export interface RemoveJitterOptions {
   target?: string;
 }
+export type PointPackingMaxOffset =
+  | { pixels: number; band?: never }
+  | { pixels?: never; band: number };
+export interface PackPointsOptions {
+  target?: string;
+  channel: "x" | "y";
+  maxOffset?: PointPackingMaxOffset;
+  padding?: number;
+  key?: string;
+  overflow?: "error" | "overlap";
+}
+export interface RemovePointPackingOptions {
+  target?: string;
+}
 export type ScaleType =
   | "linear"
   | "log"
@@ -108,17 +152,31 @@ export interface ReplaceCompositionChildOptions {
   target: string;
   program: ChartProgram;
 }
+export interface InsertCompositionChildOptions {
+  id: string;
+  program: ChartProgram;
+  before?: string;
+  after?: string;
+}
+export interface RemoveCompositionChildOptions { target: string; }
+export interface ReorderCompositionChildrenOptions {
+  order: readonly [string, ...string[]];
+}
 export type FacetScaleResolution = "shared" | "independent";
 export interface FacetScaleResolutions {
   x?: FacetScaleResolution;
   y?: FacetScaleResolution;
   xOffset?: FacetScaleResolution;
   yOffset?: FacetScaleResolution;
+  theta?: FacetScaleResolution;
+  r?: FacetScaleResolution;
   color?: FacetScaleResolution;
+  stroke?: FacetScaleResolution;
   size?: FacetScaleResolution;
   shape?: FacetScaleResolution;
   opacity?: FacetScaleResolution;
   strokeDash?: FacetScaleResolution;
+  parallelDimensions?: FacetScaleResolution;
 }
 export interface FacetGuideOptions {
   axes?: "each" | "outer";
@@ -128,6 +186,35 @@ export interface FacetOptions {
   id?: string;
   field: string;
   data?: string;
+  values?: readonly DatasetScalar[];
+  columns?: number;
+  gap?: number;
+  align?: CompositionAlign;
+  padding?: number | CompositionPadding;
+  scales?: FacetScaleResolutions;
+  guides?: FacetGuideOptions;
+}
+export interface FacetGridRole {
+  field: string;
+  values?: readonly DatasetScalar[];
+}
+export interface FacetGridOptions {
+  id?: string;
+  data?: string;
+  rows: FacetGridRole;
+  columns: FacetGridRole;
+  combinations?: "observed" | "full";
+  gap?: number;
+  align?: CompositionAlign;
+  padding?: number | CompositionPadding;
+  scales?: FacetScaleResolutions;
+  guides?: FacetGuideOptions;
+}
+export interface RepeatChartsOptions {
+  id?: string;
+  target?: string;
+  channel: "x" | "y" | "theta" | "r" | { parallelDimension: string };
+  fields: readonly [string, ...string[]];
   columns?: number;
   gap?: number;
   align?: CompositionAlign;
@@ -135,13 +222,21 @@ export interface FacetOptions {
   scales?: FacetScaleResolutions;
   guides?: FacetGuideOptions;
 }
+export interface EditFacetSourceOptions { program: ChartProgram; }
 export interface EditFacetHeadersOptions {
   fontSize?: number;
   fontFamily?: string;
   fontWeight?: string | number;
   color?: string;
   offset?: number;
-}
+  role?: FacetHeaderRole;
+  labelMap?: DisplayLabelMap | "auto";
+  side?: FacetHeaderSide;
+  align?: FacetHeaderAlign;
+}
+export type FacetHeaderRole = "all" | "row" | "column";
+export type FacetHeaderSide = "top" | "bottom" | "left" | "right";
+export type FacetHeaderAlign = "start" | "center" | "end";
 export interface ConcatCompositionSpec {
   readonly id: string;
   readonly direction: "horizontal" | "vertical";
@@ -160,8 +255,26 @@ export interface FacetCompositionSpec {
   readonly padding: Readonly<Required<CompositionPadding>>;
   readonly facet: {
     readonly data: string;
-    readonly field: string;
+    readonly field?: string;
     readonly values: readonly DatasetScalar[];
+    readonly grid?: {
+      readonly rows: { readonly field: string; readonly values: readonly DatasetScalar[] };
+      readonly columns: { readonly field: string; readonly values: readonly DatasetScalar[] };
+      readonly combinations: "observed" | "full";
+      readonly cells: readonly {
+        readonly id: string;
+        readonly row: number;
+        readonly column: number;
+        readonly rowValue: DatasetScalar;
+        readonly columnValue: DatasetScalar;
+        readonly empty: boolean;
+      }[];
+    };
+    readonly repeat?: {
+      readonly target: string;
+      readonly channel: "x" | "y" | "theta" | "r" | { readonly parallelDimension: string };
+      readonly fields: readonly string[];
+    };
     readonly scales: Readonly<Required<FacetScaleResolutions>>;
     readonly guides: {
       readonly axes: "each" | "outer";
@@ -176,6 +289,10 @@ export type DensityKernel =
   | "uniform"
   | "triangular";
 export type DensityNormalization = "unit" | "count";
+export interface StatisticalWeight {
+  readonly field: string;
+  readonly kind: "frequency" | "reliability";
+}
 export type DensityPlacementSide =
   | "both"
   | "left"
@@ -222,6 +339,13 @@ export type FilterDataOptions = {
   field: string;
 } & FilterModeOptions;
 export type DatasetScalar = string | number | boolean | null;
+export type DisplayLabelMap = ReadonlyArray<Readonly<{
+  value: DatasetScalar;
+  label: string;
+}>>;
+export interface DisplayLabelOptions {
+  labelMap?: DisplayLabelMap | "auto";
+}
 export type DatasetFilterTransform = {
   type: "filter";
   field: string;
@@ -238,22 +362,28 @@ export type DatasetRegressionTransform = {
 } & (
   | {
       method: "linear";
-      confidence: number;
       interval: "mean" | "prediction";
       degree?: never;
       span?: never;
-    }
+    } & (
+      | { confidenceMethod: ConfidenceIntervalMethod; level: number; confidence?: never }
+      | { confidence: number; confidenceMethod?: never; level?: never }
+    )
   | {
       method: "polynomial";
       degree: number;
-      confidence: number;
       interval: "mean" | "prediction";
       span?: never;
-    }
+    } & (
+      | { confidenceMethod: ConfidenceIntervalMethod; level: number; confidence?: never }
+      | { confidence: number; confidenceMethod?: never; level?: never }
+    )
   | {
       method: "loess";
       span: number;
       degree?: never;
+      confidenceMethod?: never;
+      level?: never;
       confidence?: never;
       interval?: never;
     }
@@ -267,6 +397,7 @@ export interface DatasetDensityTransform {
   steps: number;
   kernel?: DensityKernel;
   normalization?: DensityNormalization;
+  weight?: StatisticalWeight;
   as: readonly [string, string];
   resolve: "shared";
   placement?: {
@@ -284,10 +415,22 @@ export interface DatasetDensityTransform {
     };
   };
   resolved?: {
-    readonly bandwidth: number;
     readonly extent: readonly [number, number];
     readonly splitDomain?: readonly [unknown, unknown];
-  };
+  } & (
+    | {
+        readonly bandwidth: number;
+        readonly bandwidths?: never;
+      }
+    | {
+        readonly bandwidth?: never;
+        readonly bandwidths: readonly {
+          readonly group?: unknown;
+          readonly split?: unknown;
+          readonly bandwidth: number;
+        }[];
+      }
+  );
 }
 export type HorizonResolution = "shared" | "independent";
 export type HorizonMissingPolicy = "break" | "error";
@@ -304,10 +447,10 @@ export interface HorizonOutputFields {
 }
 export interface DatasetHorizonTransform {
   readonly type: "horizon";
-  readonly x: {
-    readonly field: string;
-    readonly fieldType: "quantitative" | "temporal";
-  };
+  readonly x: { readonly field: string } & (
+    | { readonly fieldType: "quantitative"; readonly temporalUnit?: never }
+    | { readonly fieldType: "temporal"; readonly temporalUnit?: TemporalInputUnit }
+  );
   readonly y: {
     readonly field: string;
     readonly fieldType: "quantitative";
@@ -346,16 +489,19 @@ export type DatasetIntervalTransform = {
   | {
       center: "mean";
       extent: "stderr" | "stdev";
+      method?: never;
       level?: never;
     }
   | {
       center: "mean";
       extent: "ci";
+      method?: ConfidenceIntervalMethod;
       level: number;
     }
   | {
       center: "median";
       extent: "iqr";
+      method?: never;
       level?: never;
     }
 );
@@ -364,6 +510,22 @@ export interface WindowSort {
   field: string;
   order?: WindowSortOrder;
 }
+export type RowWindowFrame = {
+  preceding: number;
+  following?: number;
+  duration?: never;
+};
+export type DurationWindowUnit = "millisecond" | "second" | "minute" | "hour" | "day";
+export type DurationWindowFrame = {
+  preceding?: never;
+  following?: never;
+  duration: {
+    preceding: number;
+    following?: number;
+    unit: DurationWindowUnit;
+  };
+};
+export type WindowFrame = RowWindowFrame | DurationWindowFrame;
 export type WindowOperation =
   | { op: "rowNumber" | "rank" | "denseRank"; as: string }
   | { op: "cumulativeSum"; field: string; as: string }
@@ -378,10 +540,9 @@ export type WindowOperation =
       op: "movingMean" | "movingSum";
       field: string;
       as: string;
-      frame: {
-        preceding: number;
-        following?: number;
-      };
+      frame: WindowFrame;
+      minPeriods?: number;
+      missing?: "error" | "skip";
     };
 export interface DatasetWindowSort {
   readonly field: string;
@@ -405,16 +566,48 @@ export type DatasetWindowOperation =
       readonly op: "movingMean" | "movingSum";
       readonly field: string;
       readonly as: string;
-      readonly frame: {
-        readonly preceding: number;
-        readonly following: number;
-      };
+      readonly frame:
+        | {
+            readonly preceding: number;
+            readonly following: number;
+          }
+        | {
+            readonly duration: {
+              readonly preceding: number;
+              readonly following: number;
+              readonly unit: DurationWindowUnit;
+            };
+          };
+      readonly minPeriods: number;
+      readonly missing: "error" | "skip";
     };
 export interface DatasetWindowTransform {
   readonly type: "window";
   readonly partitionBy: readonly string[];
   readonly sortBy: readonly DatasetWindowSort[];
   readonly operations: readonly DatasetWindowOperation[];
+  readonly temporalUnit?: TemporalInputUnit;
+}
+export interface ECDFOutputFields {
+  value: string;
+  cumulative: string;
+  probability: string;
+}
+export interface DatasetECDFResolvedGroup {
+  readonly keys: Readonly<Record<string, string | number | boolean>>;
+  readonly denominator: number;
+  readonly validCount: number;
+}
+export interface DatasetECDFTransform {
+  readonly type: "ecdf";
+  readonly field: string;
+  readonly groupBy: readonly string[];
+  readonly weight?: string;
+  readonly missing: "drop" | "error";
+  readonly as: Readonly<ECDFOutputFields>;
+  readonly resolved?: {
+    readonly groups: readonly DatasetECDFResolvedGroup[];
+  };
 }
 export type TimeUnit =
   | "year"
@@ -423,13 +616,28 @@ export type TimeUnit =
   | "day"
   | "hour"
   | "minute"
-  | "second";
-export interface DatasetTimeUnitTransform {
+  | "second"
+  | "week"
+  | "weekday";
+type DatasetTimeUnitTransformBase = {
   readonly type: "timeUnit";
   readonly field: string;
-  readonly unit: TimeUnit;
+  readonly temporalUnit?: TemporalInputUnit;
   readonly as: string;
-}
+  readonly timeZone?: string;
+};
+export type DatasetTimeUnitTransform = DatasetTimeUnitTransformBase & (
+  | {
+      readonly unit: Exclude<TimeUnit, "week">;
+      readonly weekStartsOn?: never;
+      readonly weekRule?: never;
+    }
+  | {
+      readonly unit: "week";
+      readonly weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+      readonly weekRule: "calendar" | "iso";
+    }
+);
 export interface Bin2DCounts {
   x: number;
   y: number;
@@ -479,20 +687,228 @@ export interface DatasetBin2DTransform {
     readonly occupiedCount: number;
   };
 }
+export interface DatasetBinTransform {
+  readonly type: "bin";
+  readonly field: string;
+  readonly bin:
+    | { readonly maxBins: number }
+    | { readonly step: number }
+    | { readonly boundaries: readonly [number, number, ...number[]] };
+  readonly extent: "auto" | readonly [number, number];
+  readonly nice: boolean;
+  readonly zero: boolean;
+  readonly includeEmpty: boolean;
+  readonly members: boolean;
+  readonly weight?: StatisticalWeight;
+  readonly as: {
+    readonly lower: string;
+    readonly upper: string;
+    readonly count: string;
+    readonly members?: string;
+  };
+  readonly resolved?: {
+    readonly domain: readonly [number, number];
+    readonly step?: number;
+    readonly boundaries: readonly [number, number, ...number[]];
+  };
+}
+export interface DatasetFoldTransform {
+  readonly type: "fold";
+  readonly fields: readonly string[];
+  readonly as: {
+    readonly key: string;
+    readonly value: string;
+  };
+}
+export type ComputedExpression =
+  | { readonly field: string }
+  | { readonly constant: number | string | boolean | null }
+  | {
+      readonly op: "negate" | "absolute" | "log" | "sqrt" | "not" | "isNull";
+      readonly operand: ComputedExpression;
+    }
+  | {
+      readonly op: "add" | "subtract" | "multiply" | "divide" |
+        "eq" | "neq" | "lt" | "lte" | "gt" | "gte";
+      readonly left: ComputedExpression;
+      readonly right: ComputedExpression;
+    }
+  | {
+      readonly op: "and" | "or" | "coalesce";
+      readonly operands: readonly [ComputedExpression, ComputedExpression, ...ComputedExpression[]];
+    }
+  | {
+      readonly op: "concat";
+      readonly operands: readonly [ComputedExpression, ...ComputedExpression[]];
+    }
+  | {
+      readonly op: "if";
+      readonly condition: ComputedExpression;
+      readonly then: ComputedExpression;
+      readonly else: ComputedExpression;
+    };
+export interface DatasetComputedTransform {
+  readonly type: "computed";
+  readonly as: string;
+  readonly expression: ComputedExpression;
+}
+export type NormalizeMethod =
+  | "share"
+  | "zscore"
+  | "minmax"
+  | "index"
+  | "change"
+  | "percentChange";
+export type NormalizeZeroDenominator = "error" | "null" | "zero";
+export type NormalizeBaseline =
+  | { readonly position: "first" | "last" }
+  | { readonly value: number };
+type DatasetNormalizedBaseTransform = {
+  readonly type: "normalize";
+  readonly field: string;
+  readonly as: string;
+  readonly groupBy: readonly string[];
+};
+type DatasetNormalizeBaselineTransform = {
+  readonly baseline: NormalizeBaseline;
+  readonly sortBy: readonly WindowSort[];
+};
+export type DatasetNormalizedTransform = DatasetNormalizedBaseTransform & (
+  | {
+      readonly method: "share" | "minmax";
+      readonly zeroDenominator: NormalizeZeroDenominator;
+    }
+  | {
+      readonly method: "zscore";
+      readonly variance: "population" | "sample";
+      readonly zeroDenominator: NormalizeZeroDenominator;
+    }
+  | ({
+      readonly method: "index" | "percentChange";
+      readonly zeroDenominator: NormalizeZeroDenominator;
+    } & DatasetNormalizeBaselineTransform)
+  | ({ readonly method: "change" } & DatasetNormalizeBaselineTransform)
+);
+export type DatasetCompleteTransform = {
+  readonly type: "complete";
+  readonly key: string;
+  readonly groupBy: readonly string[];
+  readonly fill: Readonly<Record<string, DatasetScalar>>;
+  readonly members?: string;
+} & (
+  | { readonly values: readonly DatasetScalar[]; readonly sequence?: never }
+  | {
+      readonly sequence: { readonly start: number; readonly end: number; readonly step: number };
+      readonly values?: never;
+    }
+  | { readonly values?: never; readonly sequence?: never }
+);
+type DatasetImputedBaseTransform = {
+  readonly type: "impute";
+  readonly fields: readonly string[];
+  readonly groupBy: readonly string[];
+  readonly edges: "keep" | "error";
+  readonly maxGap?: number;
+};
+export type DatasetImputedTransform = DatasetImputedBaseTransform & (
+  | {
+      readonly method: "constant";
+      readonly value: DatasetScalar;
+      readonly sortBy: readonly DatasetWindowSort[];
+    }
+  | {
+      readonly method: "forward" | "backward";
+      readonly value?: never;
+      readonly sortBy: readonly [DatasetWindowSort, ...DatasetWindowSort[]];
+    }
+  | {
+      readonly method: "linear";
+      readonly value?: never;
+      readonly sortBy: readonly [{ readonly field: string; readonly order: "ascending" }];
+    }
+);
+export type StackDataMode = "stack" | "fill" | "center" | "diverging";
+export interface StackDataOutputFields {
+  start?: string;
+  end?: string;
+  value?: string;
+  share?: string;
+}
+export interface DatasetStackTransform {
+  readonly type: "stack";
+  readonly category: string;
+  readonly group: string;
+  readonly value: string;
+  readonly mode: StackDataMode;
+  readonly as: Required<StackDataOutputFields>;
+}
+interface DatasetStatisticalReferenceTransform {
+  readonly type: "statisticalReference";
+  readonly target: string;
+}
 export type DatasetTransform =
+  | DatasetBinTransform
   | DatasetBin2DTransform
+  | DatasetCompleteTransform
+  | DatasetComputedTransform
+  | DatasetImputedTransform
+  | DatasetNormalizedTransform
   | DatasetFilterTransform
+  | DatasetFoldTransform
   | DatasetRegressionTransform
   | DatasetDensityTransform
+  | DatasetECDFTransform
   | DatasetHorizonTransform
   | DatasetIntervalTransform
+  | DatasetSummaryTransform
+  | DatasetStackTransform
+  | DatasetStatisticalReferenceTransform
   | DatasetTimeUnitTransform
   | DatasetWindowTransform;
+type RequestedTransform<T> = T extends unknown ? Omit<T, "resolved"> : never;
+export type RequestedDatasetTransform = RequestedTransform<Exclude<
+  DatasetTransform,
+  DatasetHorizonTransform | DatasetStatisticalReferenceTransform
+>>;
+export type DerivedDataDependents = "reject" | "recompute";
+export interface EditDerivedDataOptions {
+  target: string;
+  definition: RequestedDatasetTransform;
+  dependents?: DerivedDataDependents;
+}
 export interface CreateDerivedDataOptions {
   id: string;
   source: string;
   transform: readonly [DatasetTransform];
 }
+export interface DatasetSummaryTransform {
+  type: "summary";
+  groupBy: readonly string[];
+  aggregates: readonly SummaryAggregateOptions[];
+  members?: string;
+  weight?: StatisticalWeight;
+}
+export interface SummaryAggregateOptions {
+  op: AggregateOperation;
+  field?: string;
+  as: string;
+}
+export interface SummaryDataOptions {
+  id: string;
+  source?: string;
+  groupBy?: string | readonly string[];
+  aggregates: readonly SummaryAggregateOptions[];
+  members?: string;
+  weight?: StatisticalWeight;
+}
+export interface BindMarkDataOptions {
+  target: string;
+  data: string;
+}
+
+export interface RemoveResourceOptions {
+  readonly id: string;
+}
 export type MarkGraphicProperty =
   | "x" | "y" | "width" | "height" | "radius"
   | "x1" | "y1" | "x2" | "y2"
@@ -501,7 +917,7 @@ export type MarkSelector = {
   grain?: "item" | "stack";
 } & (
   | { field: string; channel?: never; property?: never }
-  | { channel: "x" | "y" | "x2" | "y2" | "xOffset" | "yOffset" | "theta" | "radius" | "color" | "strokeDash" | "size" | "shape" | "group" | "opacity"; field?: never; property?: never }
+  | { channel: "x" | "y" | "x2" | "y2" | "xOffset" | "yOffset" | "theta" | "radius" | "color" | "stroke" | "strokeDash" | "strokeWidth" | "size" | "shape" | "group" | "opacity"; field?: never; property?: never }
   | { property: MarkGraphicProperty; field?: never; channel?: never }
 ) & (
   | { op: "eq" | "neq" | "gt" | "gte" | "lt" | "lte"; value: unknown }
@@ -531,7 +947,11 @@ export interface RemoveMarkSelectionOptions {
 }
 export type FilterMarksOptions = {
   target?: string;
+  mode?: "replace" | "compose";
 } & MarkSelector;
+export interface RemoveMarkFilterOptions {
+  target?: string;
+}
 export interface HighlightMarksOptions {
   id?: string;
   target?: string;
@@ -561,12 +981,18 @@ export type ScalarAggregateOperation =
   | "distinct" | "valid" | "missing"
   | "variance" | "varianceP" | "stdev" | "stdevP" | "stderr"
   | "q1" | "q3" | "ciLower" | "ciUpper";
+export type ConfidenceIntervalMethod = "normal" | "student-t";
 export type ParameterizedAggregateOperation =
   | { op: "quantile"; probability: number }
   | {
       op: "first" | "last";
       orderBy: string;
       order?: "ascending" | "descending";
+    }
+  | {
+      op: "ciLower" | "ciUpper";
+      method?: ConfidenceIntervalMethod;
+      level?: number;
     };
 export type AggregateOperation =
   | ScalarAggregateOperation
@@ -593,6 +1019,14 @@ export type PointShape =
   | "star"
   | "hexagon"
   | "wye";
+export type StrokeStyleDetails = {
+  lineCap?: "butt" | "round" | "square";
+  lineJoin?: "miter" | "round" | "bevel";
+  miterLimit?: number;
+};
+export type RectStyleDetails = StrokeStyleDetails & {
+  cornerRadius?: number;
+};
 export type PaletteName =
   | "accent"
   | "category10" | "category20" | "category20b" | "category20c"
@@ -623,6 +1057,11 @@ export type ScaleRange = "auto" | readonly unknown[] | {
   readonly palette: Palette;
 };
 export type ActionOptions = Record<string, unknown>;
+/**
+ * One semantic assignment or removal. Complete unreferenced source datasets and
+ * coordinates can be removed; source values remain immutable. Domain removal
+ * actions own full resource/configuration lifecycle checks and cleanup.
+ */
 export type EditSemanticOptions =
   | { property: string; value: unknown; remove?: false }
   | { property: string; remove: true; value?: never };
@@ -651,7 +1090,8 @@ export interface SemanticLayer {
   readonly data?: string;
   readonly source?: string;
   readonly coordinate?: string;
-  readonly mark?: Readonly<{ type?: string; [key: string]: unknown }>;
+  readonly mark?: Readonly<{ type?: string; missing?: "error" | "break"; [key: string]: unknown }>;
+  readonly layout?: Readonly<{ mode?: ColorLayout }>;
   readonly encoding?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
   readonly [key: string]: unknown;
 }
@@ -666,7 +1106,9 @@ export interface SemanticScale {
 
 export interface SemanticCoordinate {
   readonly id: string;
-  readonly type?: "cartesian" | "polar";
+  readonly type?: "cartesian" | "polar" | "parallel";
+  readonly aspect?: CoordinateAspect;
+  readonly polarFrame?: Exclude<PolarFrameOptions, "auto">;
   readonly layers?: readonly string[];
   readonly [key: string]: unknown;
 }
@@ -705,16 +1147,32 @@ export interface CanvasOptions {
   margin?: number | Partial<Record<"top" | "right" | "bottom" | "left", number>>;
 }
 
+export interface FitCanvasOptions {
+  /** Minimum fitted margin on every Canvas edge. Defaults to 0. */
+  padding?: number;
+  /** Required final plot width. Defaults to 160. */
+  minPlotWidth?: number;
+  /** Required final plot height. Defaults to 120. */
+  minPlotHeight?: number;
+  /** Maximum binary-search probes per edge. Defaults to 32; maximum 64. */
+  iterationLimit?: number;
+  /** Reject an unsatisfied fit or preserve it with a structured overflow result. */
+  overflow?: "error" | "report";
+}
+
 export type XAxisPosition = "bottom" | "top";
 export type YAxisPosition = "left" | "right";
+export type RotationUnit = "radians" | "degrees";
+export type RotationInput = number | { value: number; unit: RotationUnit };
+type ValueFormatDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type ValueFormatPrecision = ValueFormatDigit | 10 | 11 | 12 | `0${ValueFormatDigit}`;
 type TimeAxisDirective = "Y" | "m" | "d" | "b";
-export type AxisFormatString =
-  | ".0f" | ".1f" | ".2f"
-  | ".0%" | ".1%" | ".2e"
-  | `${string}%${TimeAxisDirective}${string}`;
+export type NumericFormatString = `.${ValueFormatPrecision}${"f" | "%" | "e"}`;
+export type UtcFormatString = `${string}%${TimeAxisDirective}${string}`;
+export type ValueFormat = "auto" | NumericFormatString | UtcFormatString;
+export type AxisFormatString = NumericFormatString | UtcFormatString;
 export type AxisFormat =
-  | "auto"
-  | AxisFormatString
+  | ValueFormat
   | { decimals: number };
 export type AxisValue = string | boolean | number;
 export interface AxisLineStyleOptions {
@@ -732,13 +1190,23 @@ export interface AxisLabelStyleOptions {
   fontFamily?: string;
   fontWeight?: string | number;
 }
+export interface AxisLabelLayoutOptions {
+  /** Legacy numbers are radians; structured values make radians or degrees explicit. */
+  rotation?: RotationInput;
+  /** Wrap each label to this measured width; false removes an existing wrap policy. */
+  maxWidth?: number | false;
+  wrap?: "word" | "character";
+  lineHeight?: number;
+  /** Defaults to error; allow stores an intentional label-label overlap policy. */
+  overlap?: "error" | "allow";
+}
 export interface AxisTicksAndLabelsOptions<P extends string> {
   scale?: string;
   position?: P;
   count?: number;
   values?: readonly AxisValue[];
   ticks?: AxisTickStyleOptions;
-  labels?: AxisLabelStyleOptions;
+  labels?: AxisLabelStyleOptions & AxisLabelLayoutOptions & DisplayLabelOptions;
 }
 export interface AxisTitleOptions<P extends string> {
   text?: string;
@@ -746,7 +1214,7 @@ export interface AxisTitleOptions<P extends string> {
   position?: P;
   at?: "start" | "center" | "end" | number;
   offset?: number;
-  rotation?: number;
+  rotation?: RotationInput;
   color?: string;
   fontSize?: number;
   fontFamily?: string;
@@ -756,9 +1224,9 @@ export interface CompleteAxisOptions<P extends string> {
   scale?: string;
   coordinate?: string;
   position?: P;
-  line?: AxisLineStyleOptions;
-  ticksAndLabels?: Omit<AxisTicksAndLabelsOptions<P>, "scale" | "position">;
-  title?: Omit<AxisTitleOptions<P>, "scale" | "position">;
+  line?: false | AxisLineStyleOptions;
+  ticksAndLabels?: false | Omit<AxisTicksAndLabelsOptions<P>, "scale" | "position">;
+  title?: false | Omit<AxisTitleOptions<P>, "scale" | "position">;
 }
 export interface CreateAxesOptions {
   coordinate?: {
@@ -778,13 +1246,43 @@ export interface AxisTickOptions<P extends string>
   values?: readonly AxisValue[];
 }
 export interface AxisLabelOptions<P extends string>
-  extends AxisLabelStyleOptions {
+  extends AxisLabelStyleOptions, AxisLabelLayoutOptions, DisplayLabelOptions {
   scale?: string;
   position?: P;
   count?: number;
   values?: readonly AxisValue[];
 }
 
+export type ParallelAxisTickSelection =
+  | { count?: number; values?: never }
+  | { values: readonly AxisValue[]; count?: never };
+export type ParallelAxisTicksOptions = AxisTickStyleOptions & ParallelAxisTickSelection;
+export type ParallelAxisLabelsOptions = AxisLabelStyleOptions & ParallelAxisTickSelection;
+export interface ParallelAxisTitleOptions {
+  text?: string;
+  offset?: number;
+  color?: string;
+  fontSize?: number;
+  fontFamily?: string;
+  fontWeight?: string | number;
+}
+export type ParallelAxisComponentsOptions = {
+  field: string;
+  target?: string;
+  line?: false | AxisLineStyleOptions;
+  title?: false | ParallelAxisTitleOptions;
+} & (
+  | { ticksAndLabels?: false | (ParallelAxisTickSelection & {
+      ticks?: AxisTickStyleOptions; labels?: AxisLabelStyleOptions;
+    }); ticks?: never; labels?: never }
+  | { ticks?: false | ParallelAxisTicksOptions; labels?: false | ParallelAxisLabelsOptions;
+      ticksAndLabels?: never }
+);
+export type CreateParallelAxisOptions = ParallelAxisComponentsOptions;
+export type EditParallelAxisOptions = ParallelAxisComponentsOptions;
+export interface ParallelAxesOptions { target?: string; coordinate?: string; }
+export interface RemoveParallelAxisOptions { field: string; target?: string; }
+
 export interface PolarGuideResourceOptions {
   scale?: string;
   coordinate?: string;
@@ -804,6 +1302,11 @@ export interface PolarTicksAndLabelsOptions {
   ticks?: AxisTickStyleOptions;
   labels?: AxisLabelStyleOptions;
 }
+export type ThetaAxisLabelOptions = PolarLabelOptions & DisplayLabelOptions;
+export interface ThetaTicksAndLabelsOptions
+  extends Omit<PolarTicksAndLabelsOptions, "labels"> {
+  labels?: AxisLabelStyleOptions & DisplayLabelOptions;
+}
 export interface PolarTitleOptions {
   text?: string;
   offset?: number;
@@ -815,26 +1318,54 @@ export interface PolarTitleOptions {
 export interface RadialTitleOptions extends PolarTitleOptions {
   position?: "inside" | "outside";
 }
-export interface CompletePolarAxisOptions extends PolarGuideResourceOptions {
-  line?: AxisLineStyleOptions;
-  ticksAndLabels?: PolarTicksAndLabelsOptions;
+export type PolarAxisTickSelection =
+  | { count?: number; values?: never }
+  | { values: readonly AxisValue[]; count?: never };
+export type CreateThetaAxisLineOptions = AxisLineStyleOptions &
+  Omit<PolarGuideResourceOptions, "angle">;
+export type CreateRadialAxisLineOptions = AxisLineStyleOptions & PolarGuideResourceOptions;
+export type CreateThetaAxisTicksOptions = Omit<PolarTickOptions, "count" | "values"> &
+  PolarAxisTickSelection & Omit<PolarGuideResourceOptions, "angle">;
+export type CreateRadialAxisTicksOptions = Omit<PolarTickOptions, "count" | "values"> &
+  PolarAxisTickSelection & PolarGuideResourceOptions;
+export type CreateThetaAxisLabelsOptions = Omit<PolarLabelOptions, "count" | "values"> &
+  PolarAxisTickSelection & Omit<PolarGuideResourceOptions, "angle"> &
+  DisplayLabelOptions;
+export type CreateRadialAxisLabelsOptions = Omit<PolarLabelOptions, "count" | "values"> &
+  PolarAxisTickSelection & PolarGuideResourceOptions;
+export type CreateThetaAxisTitleOptions = PolarTitleOptions &
+  Omit<PolarGuideResourceOptions, "angle">;
+export type CreateRadialAxisTitleOptions = RadialTitleOptions & PolarGuideResourceOptions;
+export interface CompletePolarAxisOptions extends Omit<PolarGuideResourceOptions, "angle"> {
+  line?: false | AxisLineStyleOptions;
+  ticksAndLabels?: false | PolarTicksAndLabelsOptions;
   title?: false | PolarTitleOptions;
 }
+export interface CompleteThetaAxisOptions
+  extends Omit<CompletePolarAxisOptions, "ticksAndLabels"> {
+  ticksAndLabels?: false | ThetaTicksAndLabelsOptions;
+}
 export interface CompleteRadialAxisOptions
   extends Omit<CompletePolarAxisOptions, "title"> {
+  angle?: number;
   title?: false | RadialTitleOptions;
 }
 export interface EditPolarAxisOptions {
   angle?: number;
-  line?: AxisLineStyleOptions;
-  ticks?: PolarTickOptions;
-  labels?: PolarLabelOptions;
-  ticksAndLabels?: PolarTicksAndLabelsOptions;
-  title?: PolarTitleOptions;
+  line?: false | AxisLineStyleOptions;
+  ticks?: false | PolarTickOptions;
+  labels?: false | PolarLabelOptions;
+  ticksAndLabels?: false | PolarTicksAndLabelsOptions;
+  title?: false | PolarTitleOptions;
+}
+export interface EditThetaAxisOptions
+  extends Omit<EditPolarAxisOptions, "angle" | "labels" | "ticksAndLabels"> {
+  labels?: false | ThetaAxisLabelOptions;
+  ticksAndLabels?: false | ThetaTicksAndLabelsOptions;
 }
 export interface EditRadialAxisOptions
   extends Omit<EditPolarAxisOptions, "title"> {
-  title?: RadialTitleOptions;
+  title?: false | RadialTitleOptions;
 }
 
 export interface GridDirectionOptions {
@@ -894,12 +1425,67 @@ type CartesianAxesOptions = Omit<
 > & {
   coordinate?: { id?: string; type?: "auto" | "cartesian" };
 };
+type CAxisTicks<P extends string> = Omit<AxisTicksAndLabelsOptions<P>, "labels"> & {
+  labels?: AxisLabelStyleOptions & AxisLabelLayoutOptions;
+};
+type CAxis<P extends string> = Omit<CompleteAxisOptions<P>, "ticksAndLabels"> & {
+  ticksAndLabels?: false | Omit<CAxisTicks<P>, "scale" | "position">;
+};
+type CAxes = Omit<CartesianAxesOptions, "x" | "y"> & {
+  x?: false | CAxis<XAxisPosition>;
+  y?: false | CAxis<YAxisPosition>;
+};
 type CartesianGridOptions = Pick<CreateGridOptions, "horizontal" | "vertical">;
+type FilledMarkLegendOptions = Omit<LegendOptions, "symbol"> & {
+  symbol?: "auto"
+    | { width?: number; height?: number; stroke?: string; strokeWidth?: number }
+    | { layers: readonly LegendSymbolLayer[] };
+};
+type CategoricalLegendTextOptions = {
+  offset?: number;
+  color?: string;
+  fontSize?: number;
+  fontFamily?: string;
+  fontWeight?: string | number;
+  format?: "auto";
+};
+type PathLegendOptions = Omit<
+  LegendOptions,
+  "symbol" | "gradient" | "count" | "values" | "labels"
+> & {
+  symbol?: "auto" | { length?: number; lineWidth?: number }
+    | { layers: readonly LegendSymbolLayer[] };
+  labels?: CategoricalLegendTextOptions;
+};
 type CartesianGuideOptions = {
   axes?: false | CartesianAxesOptions;
   grid?: false | CartesianGridOptions;
-  legend?: false | LegendOptions;
+  legend?: false | (Omit<FilledMarkLegendOptions, "order"> & { order?: CartesianLegendOrder });
 };
+type CartesianPathGuideOptions = Omit<CartesianGuideOptions, "legend"> & {
+  legend?: false | (Omit<PathLegendOptions, "order"> & { order?: LegendValueOrder });
+};
+type CartesianCategoricalGuideOptions = Omit<CartesianGuideOptions, "legend"> & {
+  legend?: false | (Omit<
+    FilledMarkLegendOptions,
+    "count" | "values" | "gradient" | "labels" | "order"
+  > & {
+    labels?: CategoricalLegendTextOptions;
+    order?: CartesianLegendOrder;
+  });
+};
+type CPathGuides = Omit<CartesianPathGuideOptions, "axes"> & {
+  axes?: false | CAxes;
+};
+type CCategoricalGuides = Omit<CartesianCategoricalGuideOptions, "axes"> & {
+  axes?: false | CAxes;
+};
+type ColorGuides = Omit<CartesianGuideOptions, "legend"> & {
+  legend?: false | (Omit<FilledMarkLegendOptions, "values" | "order"> & {
+    order?: CartesianLegendOrder;
+  });
+};
+type BoxPlotGuideOptions = Omit<CartesianGuideOptions, "legend"> & { legend?: false };
 type GradientPlotDensityLegendOptions = {
   title?: string;
   position?: "right";
@@ -912,7 +1498,7 @@ type ParallelGuideOptions = {
     coordinate?: { id?: string; type?: "auto" | "parallel" };
   };
   grid?: false;
-  legend?: false | LegendOptions;
+  legend?: false | (Omit<PathLegendOptions, "order"> & { order?: LegendValueOrder });
 };
 
 export interface CreateCoordinateOptions {
@@ -921,7 +1507,38 @@ export interface CreateCoordinateOptions {
   layers?: readonly string[];
 }
 
+export type CoordinateAspectAlign = "start" | "center" | "end";
+export type CoordinateAspect = "auto" | {
+  mode: "frame" | "data";
+  ratio: number;
+  alignX?: CoordinateAspectAlign;
+  alignY?: CoordinateAspectAlign;
+};
+
+export type PolarFrameCenter = {
+  x: number;
+  y: number;
+};
+export type PolarFrameRadius =
+  | { unit: "fraction"; value: number }
+  | { unit: "px"; value: number };
+export type PolarFrameOptions = "auto" | {
+  center?: PolarFrameCenter;
+  radius?: PolarFrameRadius;
+};
+
+type EditCoordinateTarget = {
+  target: string;
+};
+export type EditCoordinateOptions = EditCoordinateTarget & (
+  | { aspect: CoordinateAspect; polarFrame?: PolarFrameOptions }
+  | { aspect?: CoordinateAspect; polarFrame: PolarFrameOptions }
+);
+
+export type RadialMapping = "area" | "radius-length";
+
 export interface ScaleOptions {
+  radialMapping?: RadialMapping;
   id?: string;
   type?: ScaleType;
   domain?: "auto" | readonly unknown[];
@@ -939,6 +1556,7 @@ export interface ScaleOptions {
   align?: number;
   palette?: Palette;
   interpolate?: ContinuousColorInterpolation;
+  midpoint?: number | "auto";
   unknown?: unknown;
 }
 
@@ -1002,12 +1620,59 @@ export type NonPointCategoricalColorScaleOptions = ScaleFields<"id" | "palette">
 };
 export type CategoricalColorScaleOptions =
   NonPointCategoricalColorScaleOptions & { unknown?: string };
-export type SizeScaleOptions = ScaleFields<"id"> & {
-  type?: "linear";
-  domain?: "auto" | readonly [number, number];
-  range?: "auto" | readonly [number, number];
+type SizeScaleCommonOptions = ScaleFields<"id" | "reverse"> & {
   unknown?: number;
 };
+type ContinuousSizeScaleOptions = SizeScaleCommonOptions &
+  ScaleFields<"clamp"> & {
+    domain?: "auto" | readonly [number, number];
+    range?: "auto" | readonly [number, number];
+  };
+export type SizeScaleOptions =
+  | (ContinuousSizeScaleOptions & {
+      type?: "linear";
+      base?: never;
+      exponent?: never;
+    })
+  | (ContinuousSizeScaleOptions & {
+      type: "log";
+      base?: number;
+      exponent?: never;
+    })
+  | (ContinuousSizeScaleOptions & {
+      type: "sqrt";
+      base?: never;
+      exponent?: never;
+    })
+  | (ContinuousSizeScaleOptions & {
+      type: "pow";
+      exponent: number;
+      base?: never;
+    })
+  | (SizeScaleCommonOptions & {
+      type: "quantize";
+      domain?: "auto" | readonly [number, number];
+      range: readonly [number, number, ...number[]];
+      clamp?: never;
+      base?: never;
+      exponent?: never;
+    })
+  | (SizeScaleCommonOptions & {
+      type: "quantile";
+      domain?: "auto" | readonly [number, ...number[]];
+      range: readonly [number, number, ...number[]];
+      clamp?: never;
+      base?: never;
+      exponent?: never;
+    })
+  | (SizeScaleCommonOptions & {
+      type: "threshold";
+      domain: readonly [number, ...number[]];
+      range: readonly [number, number, ...number[]];
+      clamp?: never;
+      base?: never;
+      exponent?: never;
+    });
 export type ShapeScaleOptions = ScaleFields<"id"> & {
   type?: "ordinal";
   domain?: "auto" | readonly unknown[];
@@ -1018,6 +1683,7 @@ export type ShapeScaleOptions = ScaleFields<"id"> & {
 export type CreateScaleOptions = ScaleOptions & { id: string };
 
 export interface EditScaleOptions {
+  radialMapping?: RadialMapping;
   id?: string;
   type?: ScaleType;
   domain?: "auto" | readonly unknown[];
@@ -1035,9 +1701,80 @@ export interface EditScaleOptions {
   align?: number;
   palette?: Palette;
   interpolate?: ContinuousColorInterpolation;
+  midpoint?: number | "auto";
   unknown?: unknown;
 }
 
+type FocusedScaleSelection = { id?: string; target?: string };
+export type EditXScaleOptions = FocusedScaleSelection & WithoutScaleId<
+  QuantitativePositionScaleOptions | TemporalPositionScaleOptions | CategoricalPositionScaleOptions
+>;
+export type EditYScaleOptions = EditXScaleOptions;
+export type OffsetScaleEditPatch = Pick<
+  ScaleOptions,
+  "domain" | "reverse" | "padding" | "paddingInner" | "paddingOuter" | "align"
+>;
+export type EditXOffsetScaleOptions = { target: string } & OffsetScaleEditPatch;
+export type EditYOffsetScaleOptions = EditXOffsetScaleOptions;
+export type EditParallelScaleOptions = {
+  target: string;
+  dimension: string;
+} & WithoutScaleId<
+  QuantitativePositionScaleOptions | CategoricalPositionScaleOptions
+>;
+export type EditThetaScaleOptions = FocusedScaleSelection & WithoutScaleId<ThetaScaleOptions>;
+export type EditRScaleOptions = FocusedScaleSelection & WithoutScaleId<RadiusScaleOptions> & {
+  radialMapping?: RadialMapping;
+};
+export type EditColorScaleOptions = FocusedScaleSelection & WithoutScaleId<
+  CategoricalColorScaleOptions | ContinuousColorScaleOptions | DiscretizedColorScaleOptions
+>;
+export type EditStrokeScaleOptions = { target: string } & Omit<
+  EditColorScaleOptions,
+  "id" | "target"
+>;
+type ExistingSizeScaleEditPatch = {
+  type?: never;
+  domain?: "auto" | readonly [number, ...number[]];
+  range?: "auto" | readonly [number, number, ...number[]];
+  unknown?: number;
+  clamp?: boolean;
+  reverse?: boolean;
+  base?: number;
+  exponent?: number;
+};
+type SizeScaleTypeEditPatch =
+  | (Omit<WithoutScaleId<SizeScaleOptions>, "type"> & { type?: "linear" })
+  | (Omit<Extract<WithoutScaleId<SizeScaleOptions>, { type: "log" }>, "type"> & {
+      type: "log";
+    })
+  | (Omit<Extract<WithoutScaleId<SizeScaleOptions>, { type: "sqrt" }>, "type"> & {
+      type: "sqrt";
+    })
+  | (Omit<Extract<WithoutScaleId<SizeScaleOptions>, { type: "pow" }>, "type" | "exponent"> & {
+      type: "pow";
+      exponent?: number;
+    })
+  | (Omit<Extract<WithoutScaleId<SizeScaleOptions>, { type: "quantize" }>, "type" | "range"> & {
+      type: "quantize";
+      range?: readonly [number, number, ...number[]];
+    })
+  | (Omit<Extract<WithoutScaleId<SizeScaleOptions>, { type: "quantile" }>, "type" | "range"> & {
+      type: "quantile";
+      range?: readonly [number, number, ...number[]];
+    })
+  | (Omit<Extract<WithoutScaleId<SizeScaleOptions>, { type: "threshold" }>, "type" | "domain" | "range"> & {
+      type: "threshold";
+      domain?: readonly [number, ...number[]];
+      range?: readonly [number, number, ...number[]];
+    });
+export type EditSizeScaleOptions = FocusedScaleSelection &
+  (ExistingSizeScaleEditPatch | SizeScaleTypeEditPatch);
+export type EditOpacityScaleOptions = FocusedScaleSelection & WithoutScaleId<OpacityScaleOptions>;
+export type EditShapeScaleOptions = FocusedScaleSelection & WithoutScaleId<ShapeScaleOptions>;
+export type EditStrokeWidthScaleOptions = FocusedScaleSelection & WithoutScaleId<StrokeWidthScaleOptions>;
+export type EditStrokeDashScaleOptions = FocusedScaleSelection & WithoutScaleId<DashScaleOptions>;
+
 interface PositionEncodingBase {
   field: string;
   target?: string;
@@ -1061,6 +1798,7 @@ type PositionScaleBranches<Quantitative, Temporal, Categorical> =
     }
   | {
       fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
       aggregate?: never;
       scale?: Temporal;
     }
@@ -1115,27 +1853,38 @@ export interface RadiusScaleOptions {
   constant?: number;
 }
 
-export interface ThetaEncodingOptions {
+export type ThetaEncodingOptions = {
   /**
    * Arc marks interpret an aggregate-free quantitative field as per-row sector
    * weights. Categorical arc theta retains the count and weighted-sum modes.
    */
   field: string;
   target?: string;
-  fieldType?: FieldType;
   scale?: ThetaScaleOptions;
   coordinate?: string;
   aggregate?: "count" | "sum";
   weight?: string;
-}
+} & (
+  | { fieldType?: Exclude<FieldType, "temporal">; temporalUnit?: never }
+  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit }
+);
 
-export interface RadialEncodingOptions {
-  field: string;
+export type MeasuredRadiusScaleOptions = Pick<RadiusScaleOptions, "id" | "domain" | "range" | "clamp"> & {
+  type?: "linear";
+  zero?: true;
+  nice?: false;
+  reverse?: false;
+};
+
+export type RadialEncodingOptions = {
   target?: string;
   fieldType?: "quantitative";
-  scale?: RadiusScaleOptions;
   coordinate?: string;
-}
+} & (
+  | { field: string; mapping?: false; aggregate?: never; scale?: RadiusScaleOptions }
+  | { field: string; mapping?: RadialMapping; aggregate: "sum"; scale?: MeasuredRadiusScaleOptions }
+  | { field?: never; mapping?: RadialMapping; aggregate: "count"; scale?: MeasuredRadiusScaleOptions }
+);
 
 type RulePositionValue =
   | { field: string; datum?: never }
@@ -1157,7 +1906,7 @@ type InferredRuleDatumPositionEncodingOptions = {
     | NonPointCategoricalPositionScaleOptions;
 };
 
-export type RulePositionEncodingOptions =
+export type DatumPositionEncodingOptions =
   | InferredRuleDatumPositionEncodingOptions
   | RulePositionEncodingBase & (
     | {
@@ -1166,6 +1915,7 @@ export type RulePositionEncodingOptions =
       }
     | {
         fieldType: "temporal";
+        temporalUnit?: TemporalInputUnit;
         scale?: NonPointTemporalPositionScaleOptions;
       }
     | {
@@ -1174,29 +1924,54 @@ export type RulePositionEncodingOptions =
       }
     );
 
+/** Constant primary position accepted by Rule, Rect, Area, Point, Tick, and independent Text policies. */
+export type RulePositionEncodingOptions = DatumPositionEncodingOptions;
+
+type TemporalBindingBranch =
+  | { fieldType?: "quantitative"; temporalUnit?: never }
+  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit };
+
 type SecondaryRulePositionEncodingOptions = RulePositionEncodingBase & {
-  fieldType: FieldType;
   scale?: { id?: string };
-};
+} & (
+  | { fieldType: Exclude<FieldType, "temporal">; temporalUnit?: never }
+  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit }
+);
 
 export type SecondaryPositionEncodingOptions =
   | SecondaryRulePositionEncodingOptions
-  | {
-      field: string;
-      datum?: never;
-      target?: string;
-      fieldType?: "quantitative" | "temporal";
-      scale?: { id?: string };
-      coordinate?: string;
-    };
+  | { datum: unknown; field?: never; fieldType?: "quantitative"; target?: string; scale?: { id?: string }; coordinate?: string }
+  | ({ field: string; datum?: never; target?: string; scale?: { id?: string }; coordinate?: string } & TemporalBindingBranch);
 
-export type HistogramEncodingOptions = {
-  field: string;
+type AreaRangePositionEncodingOptions = {
   target?: string;
   coordinate?: string;
-  stack?: StackMode;
-  xScale?: NonPointQuantitativePositionScaleOptions;
+  fieldType?: "quantitative";
+  temporalUnit?: never;
+  scale?: NonPointQuantitativePositionScaleOptions;
+} & (
+  | { lower: string; upper: { datum: number } }
+  | { lower: { datum: number }; upper: string }
+);
+
+type RangePositionEncodingOptions = AreaRangePositionEncodingOptions | {
+  lower: string;
+  upper: string;
+  target?: string;
+  coordinate?: string;
+} & (
+  | { fieldType?: "quantitative"; temporalUnit?: never; scale?: NonPointQuantitativePositionScaleOptions }
+  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit; scale?: NonPointTemporalPositionScaleOptions }
+);
+
+export type HistogramEncodingOptions = {
+  field: string;
+  target?: string;
+  coordinate?: string;
+  stack?: StackMode;
+  xScale?: NonPointQuantitativePositionScaleOptions;
   yScale?: NonPointZeroSupportingPositionScaleOptions;
+  weight?: StatisticalWeight;
 } & (
   | { maxBins?: number; binStep?: never; binBoundaries?: never }
   | { maxBins?: never; binStep: number; binBoundaries?: never }
@@ -1226,10 +2001,12 @@ export interface DensityDataOptions {
   steps?: number;
   kernel?: DensityKernel;
   normalization?: DensityNormalization;
+  weight?: StatisticalWeight;
   as?: readonly [string, string];
 }
 
-type DensityEncodingBase = Omit<DensityDataOptions, "id"> & {
+type DensityEncodingBase = Omit<DensityDataOptions, "id" | "groupBy"> & {
+  groupBy?: string | false;
   target?: string;
   densityChannel?: "x" | "y";
   coordinate?: string;
@@ -1254,6 +2031,7 @@ export type HorizonXEncoding = { field: string } & (
     }
   | {
       fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
       scale?: NonPointTemporalPositionScaleOptions;
     }
   | {
@@ -1286,7 +2064,7 @@ export interface HorizonEncodingOptions {
   source?: string;
   x?: string | HorizonXEncoding;
   y?: string | HorizonYEncoding;
-  groupBy?: string;
+  groupBy?: string | false;
   bands?: number;
   baseline?: number;
   extent?: "auto" | number;
@@ -1317,6 +2095,7 @@ export interface IntervalDataOptions {
   groupBy?: string | readonly string[];
   center?: IntervalCenter;
   extent?: IntervalExtent;
+  method?: ConfidenceIntervalMethod;
   level?: number;
   as?: IntervalOutputFields;
 }
@@ -1327,14 +2106,169 @@ export interface WindowDataOptions {
   partitionBy?: string | readonly string[];
   sortBy?: readonly WindowSort[];
   operations: readonly WindowOperation[];
+  temporalUnit?: TemporalInputUnit;
+}
+
+export interface ECDFDataOptions {
+  id: string;
+  source?: string;
+  field: string;
+  groupBy?: string | readonly [string, ...string[]];
+  weight?: string;
+  missing?: "drop" | "error";
+  as?: ECDFOutputFields;
 }
 
-export interface TimeUnitDataOptions {
+type TimeUnitDataBaseOptions = {
   id: string;
   source?: string;
   field: string;
-  unit: TimeUnit;
+  temporalUnit?: TemporalInputUnit;
   as: string;
+  timeZone?: string;
+};
+export type TimeUnitDataOptions = TimeUnitDataBaseOptions & (
+  | {
+      unit: Exclude<TimeUnit, "week">;
+      weekStartsOn?: never;
+      weekRule?: never;
+    }
+  | {
+      unit: "week";
+      weekRule?: "calendar";
+      weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    }
+  | {
+      unit: "week";
+      weekRule: "iso";
+      weekStartsOn?: 1;
+    }
+);
+
+export interface BinDataOutputFields {
+  lower?: string;
+  upper?: string;
+  count?: string;
+  members?: string;
+}
+type BinDataMode =
+  | { maxBins?: number; step?: never; boundaries?: never }
+  | { maxBins?: never; step: number; boundaries?: never }
+  | {
+      maxBins?: never;
+      step?: never;
+      boundaries: readonly [number, number, ...number[]];
+    };
+export type BinDataOptions = {
+  id: string;
+  source?: string;
+  field: string;
+  extent?: "auto" | readonly [number, number];
+  nice?: boolean;
+  zero?: boolean;
+  includeEmpty?: boolean;
+  members?: boolean;
+  weight?: StatisticalWeight;
+  as?: BinDataOutputFields;
+} & BinDataMode;
+
+export interface FoldDataOutputFields {
+  key?: string;
+  value?: string;
+}
+export interface FoldDataOptions {
+  id: string;
+  source?: string;
+  fields: readonly string[];
+  as?: FoldDataOutputFields;
+}
+export interface ComputedDataOptions {
+  id: string;
+  source?: string;
+  as: string;
+  expression: ComputedExpression;
+}
+type NormalizedDataBaseOptions = {
+  id: string;
+  source?: string;
+  field: string;
+  as: string;
+  groupBy?: string | readonly string[];
+};
+type NormalizeBaselineOptions =
+  | {
+      baseline?: { position: "first" | "last" };
+      sortBy: readonly [WindowSort, ...WindowSort[]];
+    }
+  | {
+      baseline: { value: number };
+      sortBy?: readonly WindowSort[];
+    };
+export type NormalizedDataOptions = NormalizedDataBaseOptions & (
+  | {
+      method: "share" | "minmax";
+      zeroDenominator?: NormalizeZeroDenominator;
+    }
+  | {
+      method: "zscore";
+      variance?: "population" | "sample";
+      zeroDenominator?: NormalizeZeroDenominator;
+    }
+  | ({
+      method: "index" | "percentChange";
+      zeroDenominator?: NormalizeZeroDenominator;
+    } & NormalizeBaselineOptions)
+  | ({ method: "change" } & NormalizeBaselineOptions)
+);
+type CompleteDataBaseOptions = {
+  id: string;
+  source?: string;
+  key: string;
+  groupBy?: string | readonly string[];
+  fill?: Readonly<Record<string, DatasetScalar>>;
+  members?: string;
+};
+export type CompleteDataOptions = CompleteDataBaseOptions & (
+  | { values: readonly [DatasetScalar, ...DatasetScalar[]]; sequence?: never }
+  | {
+      values?: never;
+      sequence: { start: number; end: number; step: number };
+    }
+  | { values?: never; sequence?: never }
+);
+type ImputedDataBaseOptions = {
+  id: string;
+  source?: string;
+  fields: string | readonly [string, ...string[]];
+  groupBy?: string | readonly string[];
+  edges?: "keep" | "error";
+  maxGap?: number;
+};
+export type ImputedDataOptions = ImputedDataBaseOptions & (
+  | {
+      method: "constant";
+      value: DatasetScalar;
+      sortBy?: readonly WindowSort[];
+    }
+  | {
+      method: "forward" | "backward";
+      value?: never;
+      sortBy: readonly [WindowSort, ...WindowSort[]];
+    }
+  | {
+      method: "linear";
+      value?: never;
+      sortBy: readonly [{ field: string; order?: "ascending" }];
+    }
+);
+export interface StackDataOptions {
+  id: string;
+  source?: string;
+  category: string;
+  group: string;
+  value: string;
+  mode?: StackDataMode;
+  as?: StackDataOutputFields;
 }
 
 export interface Bin2DDataOptions {
@@ -1359,8 +2293,51 @@ export interface EditBin2DDataOptions {
   includeEmpty?: boolean;
   members?: boolean;
   as?: DatasetBin2DOutputFields;
+  dependents?: DerivedDataDependents;
 }
 
+type FocusedDerivedDataPatch<T> = T extends unknown
+  ? Partial<Omit<T, "id" | "source">>
+  : never;
+type FocusedDerivedDataEdit<T> = {
+  target: string;
+  dependents?: DerivedDataDependents;
+} & FocusedDerivedDataPatch<T>;
+type FocusedWeightedDerivedDataEdit<T, Weight> = {
+  target: string;
+  dependents?: DerivedDataDependents;
+} & (T extends unknown
+  ? Omit<FocusedDerivedDataPatch<T>, "weight"> & { weight?: Weight | false }
+  : never);
+
+export type EditComputedDataOptions = FocusedDerivedDataEdit<ComputedDataOptions>;
+export type EditFilteredDataOptions = FocusedDerivedDataEdit<FilterDataOptions>;
+export type EditFoldDataOptions = FocusedDerivedDataEdit<FoldDataOptions>;
+export type EditSummaryDataOptions = FocusedWeightedDerivedDataEdit<
+  SummaryDataOptions,
+  StatisticalWeight
+>;
+export type EditBinDataOptions = FocusedWeightedDerivedDataEdit<
+  BinDataOptions,
+  StatisticalWeight
+>;
+export type EditTimeUnitDataOptions = FocusedDerivedDataEdit<TimeUnitDataOptions>;
+export type EditWindowDataOptions = FocusedDerivedDataEdit<WindowDataOptions>;
+export type EditDensityDataOptions = FocusedWeightedDerivedDataEdit<
+  DensityDataOptions,
+  StatisticalWeight
+>;
+export type EditStackDataOptions = FocusedDerivedDataEdit<StackDataOptions>;
+export type EditRegressionDataOptions = FocusedDerivedDataEdit<RegressionDataOptions>;
+export type EditIntervalDataOptions = FocusedDerivedDataEdit<IntervalDataOptions>;
+export type EditECDFDataOptions = FocusedWeightedDerivedDataEdit<
+  ECDFDataOptions,
+  string
+>;
+export type EditNormalizedDataOptions = FocusedDerivedDataEdit<NormalizedDataOptions>;
+export type EditCompleteDataOptions = FocusedDerivedDataEdit<CompleteDataOptions>;
+export type EditImputedDataOptions = FocusedDerivedDataEdit<ImputedDataOptions>;
+
 export type ErrorBarPositionChannel = { field?: string } & (
   | {
       fieldType?: "nominal" | "ordinal";
@@ -1368,6 +2345,7 @@ export type ErrorBarPositionChannel = { field?: string } & (
     }
   | {
       fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
       scale?: NonPointTemporalPositionScaleOptions;
     }
   | {
@@ -1380,6 +2358,7 @@ export interface ErrorBarStatisticalIntervalChannel {
   field?: string;
   center?: IntervalCenter;
   extent?: IntervalExtent;
+  method?: ConfidenceIntervalMethod;
   level?: number;
   scale?: NonPointQuantitativePositionScaleOptions;
 }
@@ -1403,7 +2382,7 @@ export interface ErrorBarOffsetChannel {
   paddingOuter?: number;
 }
 
-export interface ErrorBarOptions {
+export interface ErrorBarOptions extends StrokeStyleDetails {
   id?: string;
   target?: string;
   data?: string;
@@ -1411,7 +2390,7 @@ export interface ErrorBarOptions {
   y?: ErrorBarPositionChannel | ErrorBarIntervalChannel;
   xOffset?: ErrorBarOffsetChannel;
   yOffset?: ErrorBarOffsetChannel;
-  groupBy?: string;
+  groupBy?: string | false;
   coordinate?: string;
   caps?: boolean;
   capSize?: number;
@@ -1421,8 +2400,14 @@ export interface ErrorBarOptions {
   opacity?: number;
 }
 
-export interface EditErrorBarOptions {
+export interface EditErrorBarOptions extends StrokeStyleDetails {
   target?: string;
+  data?: string;
+  x?: ErrorBarPositionChannel | ErrorBarIntervalChannel;
+  y?: ErrorBarPositionChannel | ErrorBarIntervalChannel;
+  xOffset?: ErrorBarOffsetChannel | false;
+  yOffset?: ErrorBarOffsetChannel | false;
+  groupBy?: string | false;
   caps?: boolean;
   capSize?: number;
   stroke?: string;
@@ -1432,6 +2417,7 @@ export interface EditErrorBarOptions {
   statistics?: {
     center?: IntervalCenter;
     extent?: IntervalExtent;
+    method?: ConfidenceIntervalMethod;
     level?: number;
   };
 }
@@ -1466,22 +2452,22 @@ export interface BoxPlotOptions {
   whisker?: BoxPlotWhisker;
   width?: { band?: number };
   outliers?: boolean;
-  box?: {
+  box?: RectStyleDetails & {
     fill?: string;
     opacity?: number;
     stroke?: string;
     strokeWidth?: number;
   };
-  median?: {
+  median?: StrokeStyleDetails & {
     stroke?: string;
     strokeWidth?: number;
   };
-  outlier?: {
+  outlier?: StrokeStyleDetails & {
     shape?: PointShape;
     radius?: number;
     opacity?: number;
   };
-  guides?: false | CartesianGuideOptions;
+  guides?: false | BoxPlotGuideOptions;
 }
 
 export interface EditBoxPlotOptions {
@@ -1492,17 +2478,17 @@ export interface EditBoxPlotOptions {
   whisker?: BoxPlotWhisker;
   width?: { band?: number };
   outliers?: boolean;
-  box?: {
+  box?: RectStyleDetails & {
     fill?: string;
     opacity?: number;
     stroke?: string;
     strokeWidth?: number;
   };
-  median?: {
+  median?: StrokeStyleDetails & {
     stroke?: string;
     strokeWidth?: number;
   };
-  outlier?: {
+  outlier?: StrokeStyleDetails & {
     shape?: PointShape;
     radius?: number;
     opacity?: number;
@@ -1524,7 +2510,7 @@ export interface GradientPlotAppearanceOptions {
   opacity?: readonly [number, number];
 }
 
-export interface GradientPlotCenterOptions {
+export interface GradientPlotCenterOptions extends StrokeStyleDetails {
   type?: "mean" | "median";
   stroke?: string;
   strokeWidth?: number;
@@ -1566,7 +2552,9 @@ export type ViolinPlotPositionChannel =
 
 export interface ViolinPlotDensityOptions
   extends GradientPlotDensityOptions {
+  weight?: StatisticalWeight;
   width?: DensityPlacementWidth;
+  side?: "both" | "left" | "right" | "top" | "bottom";
 }
 
 export interface ViolinPlotSplitOptions {
@@ -1584,7 +2572,7 @@ export type ViolinPlotColorOptions =
       layout?: "overlay";
     };
 
-export interface ViolinPlotAreaOptions {
+export interface ViolinPlotAreaOptions extends StrokeStyleDetails {
   fill?: string;
   opacity?: number;
   stroke?: string;
@@ -1602,7 +2590,18 @@ export interface ViolinPlotOptions {
   color?: ViolinPlotColorOptions;
   density?: ViolinPlotDensityOptions;
   area?: ViolinPlotAreaOptions;
-  guides?: false | CartesianGuideOptions;
+  guides?: false | CartesianCategoricalGuideOptions;
+}
+
+export interface EditViolinPlotOptions {
+  target?: string;
+  data?: string;
+  x?: ViolinPlotPositionChannel;
+  y?: ViolinPlotPositionChannel;
+  split?: false | ViolinPlotSplitOptions;
+  density?: Omit<ViolinPlotDensityOptions, "weight"> & {
+    weight?: StatisticalWeight | false;
+  };
 }
 
 export interface EditGradientPlotOptions {
@@ -1629,6 +2628,7 @@ type PointFacadePositionChannel =
         }
       | {
           fieldType: "temporal";
+          temporalUnit?: TemporalInputUnit;
           scale?: TemporalPositionScaleOptions;
         }
       | {
@@ -1645,6 +2645,7 @@ type LineXPositionChannel =
         }
       | {
           fieldType: "temporal";
+          temporalUnit?: TemporalInputUnit;
           scale?: NonPointTemporalPositionScaleOptions;
         }
     ));
@@ -1658,6 +2659,7 @@ type LineYPositionChannel =
         }
       | {
           fieldType: "temporal";
+          temporalUnit?: TemporalInputUnit;
           aggregate?: never;
           scale?: NonPointTemporalPositionScaleOptions;
         }
@@ -1669,6 +2671,14 @@ type BandPositionChannel = FacadePositionChannel<
 >;
 type BarYPositionChannel =
   | string
+  | {
+      field: string;
+      fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
+      aggregate?: never;
+      stack?: never;
+      scale?: NonPointTemporalPositionScaleOptions;
+    }
   | ({ field: string; stack?: StackMode } & (
       | {
           fieldType?: "quantitative";
@@ -1703,7 +2713,8 @@ type BasicColorChannel =
   | {
       field: string;
       fieldType: "temporal";
-      scale?: ContinuousColorScaleOptions;
+      temporalUnit?: TemporalInputUnit;
+      scale?: Omit<ContinuousColorScaleOptions, "midpoint"> & { midpoint?: "auto" };
       palette?: Palette;
     };
 type NonPointCategoricalColorChannel =
@@ -1767,7 +2778,8 @@ type RectColorChannel =
   | {
       field: string;
       fieldType: "temporal";
-      scale?: NonPointContinuousColorScaleOptions;
+      temporalUnit?: TemporalInputUnit;
+      scale?: Omit<NonPointContinuousColorScaleOptions, "midpoint"> & { midpoint?: "auto" };
       palette?: Palette;
     };
 export type BasicSizeChannel = string | {
@@ -1810,45 +2822,513 @@ export interface ParallelCoordinatesEncodingOptions {
   coordinate?: string;
   dimensions: readonly [ParallelDimension, ParallelDimension, ...ParallelDimension[]];
   key?: string;
-  missing?: ParallelMissingPolicy;
+  missing?: ParallelMissingPolicy;
+}
+export interface CreateParallelCoordinatesOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  dimensions: readonly [ParallelDimension, ParallelDimension, ...ParallelDimension[]];
+  key?: string;
+  missing?: ParallelMissingPolicy;
+  color?: LineCategoricalColorChannel;
+  strokeDash?: BasicStrokeDashChannel;
+  line?: StrokeStyleDetails & {
+    strokeWidth?: number;
+    stroke?: string;
+    opacity?: number;
+    curve?: "linear";
+    closed?: false;
+  };
+  guides?: false | ParallelGuideOptions;
+}
+
+export interface CreateScatterPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  x: PointFacadePositionChannel;
+  y: PointFacadePositionChannel;
+  color?: BasicColorChannel;
+  size?: BasicSizeChannel;
+  shape?: BasicShapeChannel;
+  point?: StrokeStyleDetails & {
+    radius?: number;
+    shape?: PointShape;
+    fill?: string;
+    opacity?: number;
+    stroke?: FilledMarkStroke;
+    strokeWidth?: number;
+  };
+  guides?: false | CartesianGuideOptions;
+}
+
+export interface IntervalPlotErrorBarOptions extends StrokeStyleDetails {
+  caps?: boolean;
+  capSize?: number;
+  stroke?: string;
+  strokeWidth?: number;
+  strokeDash?: DashStyle | DashPattern;
+  opacity?: number;
+}
+type IntervalPlotBaseOptions = {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  xOffset?: ErrorBarOffsetChannel;
+  yOffset?: ErrorBarOffsetChannel;
+  groupBy?: string | false;
+  color?: BasicColorChannel;
+  point?: CreateScatterPlotOptions["point"];
+  errorBar?: IntervalPlotErrorBarOptions;
+  guides?: false | CartesianGuideOptions;
+};
+export type CreateIntervalPlotOptions = IntervalPlotBaseOptions & (
+  | {
+      x: string | ErrorBarPositionChannel;
+      y: string | ErrorBarIntervalChannel;
+    }
+  | {
+      x: string | ErrorBarIntervalChannel;
+      y: string | ErrorBarPositionChannel;
+    }
+);
+
+export type RegressionPlotPositionChannel = string | {
+  field: string;
+  fieldType?: "quantitative";
+  scale?: NonPointQuantitativePositionScaleOptions;
+};
+type RegressionPlotBaseOptions = {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  x: RegressionPlotPositionChannel;
+  y: RegressionPlotPositionChannel;
+  color?: BasicColorChannel;
+  size?: BasicSizeChannel;
+  shape?: BasicShapeChannel;
+  point?: CreateScatterPlotOptions["point"];
+  guides?: false | CartesianGuideOptions;
+};
+type RegressionPlotStatisticalOptions<T> = T extends unknown
+  ? Omit<T, "target" | "x" | "y">
+  : never;
+export type CreateRegressionPlotOptions = RegressionPlotBaseOptions &
+  RegressionPlotStatisticalOptions<RegressionOptions>;
+
+export type EndpointPlotSummary = false | "mean" | "median" | "sum" | "min" | "max";
+export type EndpointCategoryChannel = string | {
+  field: string;
+  fieldType?: "nominal" | "ordinal";
+  scale?: NonPointCategoricalPositionScaleOptions;
+};
+export type EndpointValueChannel = string | {
+  field: string;
+  fieldType?: "quantitative";
+  scale?: NonPointQuantitativePositionScaleOptions;
+};
+export type EndpointLabelOptions = Omit<
+  TextMarkOptions,
+  "id" | "data" | "source" | "text"
+> & {
+  format?: TextFormat;
+  layout?: false | Omit<LabelLayoutOptions, "target">;
+} & (
+  | { field?: string; value?: never }
+  | { field?: never; value: unknown }
+);
+type EndpointPlotBaseOptions = {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  category: EndpointCategoryChannel;
+  orientation?: "horizontal" | "vertical";
+  summary?: EndpointPlotSummary;
+  guides?: false | CartesianGuideOptions;
+};
+export interface CreateDotPlotOptions extends EndpointPlotBaseOptions {
+  value: EndpointValueChannel;
+  point?: CreateScatterPlotOptions["point"];
+  labels?: false | EndpointLabelOptions;
+}
+export interface CreateLollipopPlotOptions extends EndpointPlotBaseOptions {
+  value: EndpointValueChannel;
+  baseline?: number;
+  point?: CreateScatterPlotOptions["point"];
+  stem?: RuleStyleOptions;
+  labels?: false | EndpointLabelOptions;
+}
+export interface CreateDumbbellPlotOptions extends EndpointPlotBaseOptions {
+  start: EndpointValueChannel;
+  end: EndpointValueChannel;
+  startPoint?: CreateScatterPlotOptions["point"];
+  endPoint?: CreateScatterPlotOptions["point"];
+  connector?: RuleStyleOptions;
+  labels?: false | (EndpointLabelOptions & { endpoint?: "start" | "end" | "both" });
+}
+export type EditEndpointPlotOptions = { target?: string } & Partial<Pick<
+  CreateDumbbellPlotOptions,
+  "data" | "coordinate" | "category" | "start" | "end" | "orientation" | "summary"
+>> & {
+  value?: EndpointValueChannel;
+  baseline?: number;
+};
+
+export interface CreateECDFPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  field: string;
+  groupBy?: string | readonly [string, ...string[]];
+  weight?: string;
+  missing?: "drop" | "error";
+  as?: ECDFOutputFields;
+  color?: string | LineCategoricalColorChannel;
+  line?: StrokeStyleDetails & { strokeWidth?: number; stroke?: string; opacity?: number };
+  labels?: false | EndpointLabelOptions;
+  guides?: false | CartesianPathGuideOptions;
+}
+export type EditECDFPlotOptions = { target?: string } & Partial<Pick<
+  CreateECDFPlotOptions,
+  "data" | "coordinate" | "field" | "missing" | "as"
+>> & {
+  groupBy?: CreateECDFPlotOptions["groupBy"] | false;
+  weight?: string | false;
+  color?: CreateECDFPlotOptions["color"] | false;
+};
+
+export type PolarThetaChannel = string | ({ field: string; scale?: ThetaScaleOptions } & (
+  | { fieldType?: "quantitative" | "nominal" | "ordinal"; temporalUnit?: never }
+  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit }
+));
+export type PolarRadiusChannel = string | {
+  field: string;
+  fieldType?: "quantitative";
+  scale?: RadiusScaleOptions;
+};
+export type PolarChartGuideOptions = {
+  axes?: false | Pick<CreateAxesOptions, "theta" | "radius"> & {
+    coordinate?: { id?: string; type?: "auto" | "polar" };
+  };
+  grid?: false | Pick<CreateGridOptions, "theta" | "radial">;
+  legend?: false | LegendOptions;
+};
+type PolarLegendOrder = LegendValueOrder | { channel: "theta"; values?: never };
+type PolarPathLegendOptions = Omit<PathLegendOptions, "order"> & {
+  order?: PolarLegendOrder;
+};
+type PolarPointLegendOptions = Omit<FilledMarkLegendOptions, "order"> & {
+  order?: PolarLegendOrder;
+};
+export type PolarPathGuideOptions = Omit<PolarChartGuideOptions, "legend"> & {
+  legend?: false | PolarPathLegendOptions;
+};
+export type PolarPointGuideOptions = Omit<PolarChartGuideOptions, "legend"> & {
+  legend?: false | PolarPointLegendOptions;
+};
+export interface CreatePolarScatterPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  theta: PolarThetaChannel;
+  radius: PolarRadiusChannel;
+  color?: BasicColorChannel;
+  size?: BasicSizeChannel;
+  shape?: BasicShapeChannel;
+  point?: CreateScatterPlotOptions["point"];
+  guides?: false | PolarPointGuideOptions;
+}
+export interface CreatePolarLinePlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  theta: PolarThetaChannel;
+  radius: PolarRadiusChannel;
+  color?: LineCategoricalColorChannel;
+  groupBy?: string | readonly [string, ...string[]];
+  strokeDash?: BasicStrokeDashChannel;
+  line?: Omit<NonNullable<CreateLinePlotOptions["line"]>, "closed" | "curve"> & {
+    curve?: "linear";
+    closed?: boolean;
+  };
+  guides?: false | PolarPathGuideOptions;
+}
+export type RadarCategoryValue = string | number | boolean;
+export type RadarCategoryScaleOptions = Pick<
+  ThetaScaleOptions,
+  "id" | "domain" | "range" | "reverse" | "paddingInner" | "paddingOuter" |
+  "padding" | "align"
+> & { type?: "band" | "point" };
+export type RadarCategoryChannel = string | {
+  field: string;
+  fieldType?: "nominal" | "ordinal";
+  scale?: RadarCategoryScaleOptions;
+};
+type CategoricalThetaTicksAndLabelsOptions = Omit<
+  PolarTicksAndLabelsOptions,
+  "count" | "labels"
+> & {
+  count?: never;
+  labels?: Omit<AxisLabelStyleOptions, "format"> & DisplayLabelOptions &
+    { format?: "auto" };
+};
+type CategoricalThetaAxisOptions = Omit<CompletePolarAxisOptions, "ticksAndLabels"> & {
+  ticksAndLabels?: false | CategoricalThetaTicksAndLabelsOptions;
+};
+type CategoricalThetaGridOptions = Omit<PolarGridOptions, "count"> & {
+  count?: never;
+};
+type CategoricalPolarAxesOptions = Omit<
+  Pick<CreateAxesOptions, "theta" | "radius">,
+  "theta"
+> & {
+  coordinate?: { id?: string; type?: "auto" | "polar" };
+  theta?: false | CategoricalThetaAxisOptions;
+};
+type CategoricalPolarGridOptions = Omit<
+  Pick<CreateGridOptions, "theta" | "radial">,
+  "theta"
+> & {
+  theta?: boolean | CategoricalThetaGridOptions;
+};
+export type RadarGuideOptions = Omit<PolarPathGuideOptions, "axes" | "grid" | "legend"> & {
+  axes?: false | CategoricalPolarAxesOptions;
+  grid?: false | CategoricalPolarGridOptions;
+  legend?: false | (Omit<PathLegendOptions, "order"> & { order?: LegendValueOrder });
+};
+export interface RadarWideOptions {
+  fields: readonly [string, string, string, ...string[]];
+  as?: { key?: string; value?: string };
+}
+export type CreateRadarPlotOptions = {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  groupBy?: string | readonly [string, ...string[]];
+  order?: readonly [
+    RadarCategoryValue,
+    RadarCategoryValue,
+    RadarCategoryValue,
+    ...RadarCategoryValue[]
+  ];
+  color?: LineCategoricalColorChannel;
+  strokeDash?: BasicStrokeDashChannel;
+  line?: Omit<NonNullable<CreateLinePlotOptions["line"]>, "closed" | "curve"> & {
+    curve?: "linear";
+    closed?: true;
+  };
+  guides?: false | RadarGuideOptions;
+} & (
+  | { category: RadarCategoryChannel; value: PolarRadiusChannel; wide?: never }
+  | { wide: RadarWideOptions; category?: never; value?: never }
+);
+export type RugMeasureChannel = string | (
+  | {
+      field: string;
+      fieldType?: "quantitative";
+      temporalUnit?: never;
+      scale?: NonPointQuantitativePositionScaleOptions;
+    }
+  | {
+      field: string;
+      fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
+      scale?: NonPointTemporalPositionScaleOptions;
+    }
+);
+export interface RugTickOptions extends StrokeStyleDetails {
+  length?: number;
+  stroke?: string;
+  strokeWidth?: number;
+  opacity?: number;
+}
+export type RugGuideOptions = Omit<CartesianGuideOptions, "axes" | "legend"> & {
+  axes?: false | CAxes;
+  legend?: false;
+};
+export type CreateRugPlotOptions = {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  tick?: RugTickOptions;
+  guides?: false | RugGuideOptions;
+} & (
+  | { x: RugMeasureChannel; y?: never; edge: "top" | "bottom" }
+  | { y: RugMeasureChannel; x?: never; edge: "left" | "right" }
+);
+export type StripCategoryChannel = string | {
+  field: string;
+  fieldType?: "nominal" | "ordinal";
+  scale?: CategoricalPositionScaleOptions;
+};
+export interface StripPixelJitterOptions {
+  maxOffset: { pixels: number; band?: never };
+  seed?: string | number;
+  key?: string;
 }
-export interface CreateParallelCoordinatesOptions {
+export interface StripBandJitterOptions {
+  maxOffset: { pixels?: never; band: number };
+  seed?: string | number;
+  key?: string;
+}
+export type StripJitterOptions = StripPixelJitterOptions | StripBandJitterOptions;
+export type CreateStripPlotOptions = {
   id?: string;
   data?: string;
   coordinate?: string;
-  dimensions: readonly [ParallelDimension, ParallelDimension, ...ParallelDimension[]];
-  key?: string;
-  missing?: ParallelMissingPolicy;
-  color?: LineCategoricalColorChannel;
-  strokeDash?: BasicStrokeDashChannel;
-  line?: {
-    strokeWidth?: number;
-    stroke?: string;
+  color?: BasicColorChannel;
+  size?: BasicSizeChannel;
+  shape?: BasicShapeChannel;
+  point?: StrokeStyleDetails & {
+    radius?: number;
+    shape?: PointShape;
+    fill?: string;
     opacity?: number;
-    curve?: "linear";
-    closed?: false;
+    stroke?: FilledMarkStroke;
+    strokeWidth?: number;
   };
-  guides?: false | ParallelGuideOptions;
+  guides?: false | CartesianGuideOptions;
+} & (
+  | { x: RugMeasureChannel; y?: never; jitter?: false | StripPixelJitterOptions }
+  | { x: RugMeasureChannel; y: StripCategoryChannel; jitter?: false | StripBandJitterOptions }
+  | { x: StripCategoryChannel; y: RugMeasureChannel; jitter?: false | StripBandJitterOptions }
+);
+export interface BeeswarmPackingOptions {
+  maxOffset?: PointPackingMaxOffset;
+  padding?: number;
+  key?: string;
+  overflow?: "error" | "overlap";
 }
-
-export interface CreateScatterPlotOptions {
+export type CreateBeeswarmPlotOptions = {
   id?: string;
   data?: string;
   coordinate?: string;
-  x: PointFacadePositionChannel;
-  y: PointFacadePositionChannel;
   color?: BasicColorChannel;
   size?: BasicSizeChannel;
   shape?: BasicShapeChannel;
-  point?: {
+  point?: StrokeStyleDetails & {
+    radius?: number;
     shape?: PointShape;
     fill?: string;
     opacity?: number;
-    stroke?: string;
+    stroke?: FilledMarkStroke;
     strokeWidth?: number;
   };
-  guides?: false | CreateGuidesOptions;
+  packing?: false | BeeswarmPackingOptions;
+  guides?: false | CartesianGuideOptions;
+} & (
+  | { x: RugMeasureChannel; y: StripCategoryChannel }
+  | { x: StripCategoryChannel; y: RugMeasureChannel }
+);
+
+export interface RaincloudDensityOptions extends GradientPlotDensityOptions {
+  width?: DensityPlacementWidth;
+  area?: ViolinPlotAreaOptions;
+}
+export interface RaincloudBoxSummaryOptions {
+  type?: "box";
+  whisker?: BoxPlotWhisker;
+  width?: { band?: number };
+  outliers?: boolean;
+  box?: BoxPlotOptions["box"];
+  median?: BoxPlotOptions["median"];
+  outlier?: BoxPlotOptions["outlier"];
+}
+export interface RaincloudIntervalSummaryOptions {
+  type: "interval";
+  center?: IntervalCenter;
+  extent?: IntervalExtent;
+  method?: ConfidenceIntervalMethod;
+  level?: number;
+  point?: CreateScatterPlotOptions["point"];
+  errorBar?: IntervalPlotErrorBarOptions;
+}
+export type RaincloudSummaryOptions =
+  | RaincloudBoxSummaryOptions
+  | RaincloudIntervalSummaryOptions;
+export interface RaincloudPointAppearanceOptions {
+  size?: BasicSizeChannel;
+  shape?: BasicShapeChannel;
+  point?: CreateScatterPlotOptions["point"];
+}
+export type RaincloudPointsOptions =
+  | (RaincloudPointAppearanceOptions & {
+      type: "strip";
+      jitter?: false | StripBandJitterOptions;
+      packing?: never;
+    })
+  | (RaincloudPointAppearanceOptions & {
+      type?: "beeswarm";
+      packing?: false | BeeswarmPackingOptions;
+      jitter?: never;
+    });
+export type RaincloudCategoryChannel = string | {
+  field: string;
+  fieldType?: "nominal" | "ordinal";
+  scale?: NonPointBandPositionScaleOptions;
+};
+export type RaincloudValueChannel = string | {
+  field: string;
+  fieldType?: "quantitative";
+  scale?: NonPointQuantitativePositionScaleOptions;
+};
+export interface CreateRaincloudPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  category: RaincloudCategoryChannel;
+  value: RaincloudValueChannel;
+  orientation?: "vertical" | "horizontal";
+  side?: "before" | "after";
+  density?: false | RaincloudDensityOptions;
+  summary?: false | RaincloudSummaryOptions;
+  points?: false | RaincloudPointsOptions;
+  color?: LineCategoricalColorChannel;
+  guides?: false | CartesianCategoricalGuideOptions;
 }
+export interface EditRaincloudPlotOptions {
+  target?: string;
+  data?: string;
+  category?: RaincloudCategoryChannel;
+  value?: RaincloudValueChannel;
+  orientation?: "vertical" | "horizontal";
+  side?: "before" | "after";
+  density?: false | RaincloudDensityOptions;
+  summary?: false | RaincloudSummaryOptions;
+  points?: false | RaincloudPointsOptions;
+  color?: false | LineCategoricalColorChannel;
+}
+
+export type GroupEncodingOptions = { target?: string; fieldType?: "nominal" } & (
+  | { field: string; fields?: never }
+  | { fields: readonly [string, ...string[]]; field?: never }
+);
+
+export interface SeriesLayoutOptions { target?: string; mode: ColorLayout; }
+export interface BasicSeriesLayoutOptions { target?: string; mode: Exclude<ColorLayout, "center">; }
+export type AreaPlotIndependentChannel = string | ({ field: string } & (
+  | { fieldType?: "quantitative"; scale?: NonPointQuantitativePositionScaleOptions }
+  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit; scale?: NonPointTemporalPositionScaleOptions }
+));
+export type AreaPlotMeasureChannel = string | { field: string; scale?: NonPointQuantitativePositionScaleOptions }
+  | ({ scale?: NonPointQuantitativePositionScaleOptions } & (
+    | { lower: string; upper: string | { datum: number } }
+    | { lower: { datum: number }; upper: string }
+  ));
+export type CreateAreaPlotOptions = {
+  id?: string; data?: string; coordinate?: string;
+  groupBy?: string | readonly [string, ...string[]];
+  layout?: Exclude<ColorLayout, "group">; missing?: "error" | "break";
+  color?: string | { field: string; fieldType?: "nominal" | "ordinal"; scale?: NonPointCategoricalColorScaleOptions; palette?: Palette };
+  area?: StrokeStyleDetails & { fill?: string; opacity?: number; stroke?: string; strokeWidth?: number; curve?: CurveInterpolation };
+  guides?: false | DensityPlotGuideOptions;
+} & (
+  | { valueChannel?: "y"; x: AreaPlotIndependentChannel; y: Exclude<AreaPlotMeasureChannel, { lower: unknown }>; baseline?: number }
+  | { valueChannel?: "y"; x: AreaPlotIndependentChannel; y: Extract<AreaPlotMeasureChannel, { lower: unknown }>; baseline?: never }
+  | { valueChannel: "x"; x: Exclude<AreaPlotMeasureChannel, { lower: unknown }>; y: AreaPlotIndependentChannel; baseline?: number }
+  | { valueChannel: "x"; x: Extract<AreaPlotMeasureChannel, { lower: unknown }>; y: AreaPlotIndependentChannel; baseline?: never }
+);
 
 export interface CreateLinePlotOptions {
   id?: string;
@@ -1857,16 +3337,16 @@ export interface CreateLinePlotOptions {
   x: LineXPositionChannel;
   y: LineYPositionChannel;
   color?: LineCategoricalColorChannel;
-  groupBy?: string;
+  groupBy?: string | readonly [string, ...string[]];
   strokeDash?: BasicStrokeDashChannel;
-  line?: {
+  line?: StrokeStyleDetails & {
     strokeWidth?: number;
     curve?: CurveInterpolation;
     stroke?: string;
     opacity?: number;
     closed?: false;
   };
-  guides?: false | CreateGuidesOptions;
+  guides?: false | CPathGuides;
 }
 
 type BasicHistogramEncoding =
@@ -1886,13 +3366,13 @@ export interface CreateBarPlotOptions {
   y: BarYPositionChannel;
   color?: BarColorChannel;
   width?: Omit<BarWidthOptions, "target">;
-  bar?: {
+  bar?: RectStyleDetails & {
     fill?: string;
     opacity?: number;
-    stroke?: string;
+    stroke?: FilledMarkStroke;
     strokeWidth?: number;
   };
-  guides?: false | CreateGuidesOptions;
+  guides?: false | ColorGuides;
 }
 
 export type CreateHistogramOptions = BasicHistogramEncoding & {
@@ -1901,20 +3381,115 @@ export type CreateHistogramOptions = BasicHistogramEncoding & {
   coordinate?: string;
   field: string;
   color?: HistogramCategoricalColorChannel;
-  bar?: {
+  bar?: RectStyleDetails & {
     fill?: string;
     opacity?: number;
-    stroke?: string;
+    stroke?: FilledMarkStroke;
     strokeWidth?: number;
   };
-  guides?: false | CreateGuidesOptions;
+  guides?: false | CartesianCategoricalGuideOptions;
+};
+
+export type HorizonPlotGuideOptions = {
+  axes?: false | (Omit<CAxes, "y"> & { y?: false });
+  grid?: false | (Pick<CartesianGridOptions, "vertical"> & { horizontal?: false });
+  legend?: false;
+};
+export interface CreateHorizonPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  x: string | HorizonXEncoding;
+  y: string | HorizonYEncoding;
+  groupBy?: string | false;
+  bands?: number;
+  baseline?: number;
+  extent?: "auto" | number;
+  resolve?: HorizonResolution;
+  missing?: HorizonMissingPolicy;
+  overflow?: HorizonOverflowPolicy;
+  palette?: HorizonPaletteOptions;
+  area?: StrokeStyleDetails & { opacity?: number; stroke?: string; strokeWidth?: number; curve?: CurveInterpolation };
+  guides?: false | HorizonPlotGuideOptions;
+}
+
+export type DensityPlotLegendOptions = Omit<PieLegendOptions, "order"> & { order?: LegendValueOrder };
+export type DensityPlotGuideOptions = Omit<CCategoricalGuides, "legend"> & {
+  legend?: false | DensityPlotLegendOptions;
+};
+export interface CreateDensityPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  field: string;
+  groupBy?: string | false;
+  bandwidth?: "auto" | number;
+  extent?: "auto" | readonly [number, number];
+  steps?: number;
+  kernel?: DensityKernel;
+  normalization?: DensityNormalization;
+  weight?: StatisticalWeight;
+  as?: readonly [string, string];
+  densityChannel?: "x" | "y";
+  valueScale?: NonPointQuantitativePositionScaleOptions;
+  densityScale?: NonPointZeroSupportingPositionScaleOptions;
+  color?: string | {
+    field: string;
+    fieldType?: "nominal" | "ordinal";
+    scale?: NonPointCategoricalColorScaleOptions;
+    palette?: Palette;
+    layout?: "overlay";
+  };
+  area?: StrokeStyleDetails & { fill?: string; opacity?: number; stroke?: string; strokeWidth?: number; curve?: CurveInterpolation };
+  guides?: false | DensityPlotGuideOptions;
+}
+
+export type PieCategory = string | {
+  field: string;
+  fieldType?: "nominal" | "ordinal";
+  scale?: Pick<ThetaScaleOptions, "id" | "domain" | "range" | "reverse"> & { type?: "band" };
 };
+export type PieColor = string | {
+  field: string;
+  fieldType?: "nominal" | "ordinal";
+  scale?: NonPointCategoricalColorScaleOptions;
+  palette?: Palette;
+};
+export type PieLegendOptions = Omit<
+  FilledMarkLegendOptions,
+  "count" | "values" | "gradient" | "channels" | "order" | "labels"
+> & {
+  channels?: readonly ["color"];
+  order?: LegendValueOrder | { channel: "theta"; values?: never };
+  labels?: CategoricalLegendTextOptions;
+};
+export type CreatePiePlotOptions = {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  category: PieCategory;
+  color?: false | PieColor;
+  arc?: StrokeStyleDetails & { innerRadius?: number; padAngle?: number; fill?: string; opacity?: number; stroke?: string; strokeWidth?: number };
+  guides?: false | { axes?: false; grid?: false; legend?: false | PieLegendOptions };
+} & ({ value?: never; aggregate?: "count" } | { value: string; aggregate: "sum" });
+
+export type MeasuredRadialGuideOptions = {
+  axes?: false | CategoricalPolarAxesOptions;
+  grid?: false | CategoricalPolarGridOptions;
+  legend?: false | PieLegendOptions;
+};
+export type CreateRosePlotOptions = Omit<CreatePiePlotOptions, "guides" | "arc" | "aggregate" | "value"> & {
+  radiusScale?: MeasuredRadiusScaleOptions;
+  arc?: StrokeStyleDetails & { innerRadius?: number; padAngle?: 0; fill?: string; opacity?: number; stroke?: string; strokeWidth?: number };
+  guides?: false | MeasuredRadialGuideOptions;
+} & ({ value?: never; aggregate?: "count" } | { value: string; aggregate: "sum" });
+export type CreateRadialBarPlotOptions = CreateRosePlotOptions;
 
 export interface HeatmapBaseOptions {
   id?: string;
   data?: string;
   coordinate?: string;
-  rect?: {
+  rect?: RectStyleDetails & {
     opacity?: number;
     stroke?: string | false;
     strokeWidth?: number;
@@ -1974,6 +3549,7 @@ export type ErrorBandPositionChannel = { field?: string } & (
     }
   | {
       fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
       scale?: NonPointTemporalPositionScaleOptions;
     }
 );
@@ -1982,6 +3558,7 @@ export interface ErrorBandStatisticalIntervalChannel {
   field?: string;
   center?: IntervalCenter;
   extent?: IntervalExtent;
+  method?: ConfidenceIntervalMethod;
   level?: number;
   scale?: NonPointQuantitativePositionScaleOptions;
 }
@@ -1997,7 +3574,7 @@ export type ErrorBandIntervalChannel =
   | ErrorBandStatisticalIntervalChannel
   | ErrorBandExplicitIntervalChannel;
 
-export interface ErrorBandOptions {
+export interface ErrorBandOptions extends StrokeStyleDetails {
   id?: string;
   target?: string;
   data?: string;
@@ -2008,35 +3585,40 @@ export interface ErrorBandOptions {
   fill?: string;
   opacity?: number;
   curve?: CurveInterpolation;
-  boundaries?: false | {
+  boundaries?: false | (StrokeStyleDetails & {
     stroke?: string;
     strokeWidth?: number;
     strokeDash?: DashStyle | DashPattern;
     opacity?: number;
     curve?: CurveInterpolation;
-  };
+  });
 }
 
-export interface EditErrorBandOptions {
+export interface EditErrorBandOptions extends StrokeStyleDetails {
   target?: string;
-  fill?: string;
+  data?: string;
+  x?: ErrorBandPositionChannel | ErrorBandIntervalChannel;
+  y?: ErrorBandPositionChannel | ErrorBandIntervalChannel;
+  groupBy?: string | false;
+  fill?: string | false;
   opacity?: number;
   curve?: CurveInterpolation;
   statistics?: {
     center?: IntervalCenter;
     extent?: IntervalExtent;
+    method?: ConfidenceIntervalMethod;
     level?: number;
   };
-  boundaries?: false | {
+  boundaries?: false | (StrokeStyleDetails & {
     stroke?: string;
     strokeWidth?: number;
     strokeDash?: DashStyle | DashPattern;
     opacity?: number;
     curve?: CurveInterpolation;
-  };
+  });
 }
 
-export interface EditErrorBandBoundaryOptions {
+export interface EditErrorBandBoundaryOptions extends StrokeStyleDetails {
   target?: string;
   boundary?: "both" | "lower" | "upper";
   stroke?: string;
@@ -2056,6 +3638,9 @@ export interface EditDensityOptions {
   steps?: number;
   kernel?: DensityKernel;
   normalization?: DensityNormalization;
+  weight?: StatisticalWeight | false;
+  densityChannel?: "x" | "y";
+  valueScale?: NonPointQuantitativePositionScaleOptions;
   placement?: DensityPlacement;
 }
 
@@ -2063,7 +3648,11 @@ export interface OffsetScaleOptions {
   id?: string;
   type?: "ordinal";
   domain?: "auto" | readonly unknown[];
-  range?: "auto" | readonly [number, number];
+  reverse?: boolean;
+  padding?: number;
+  paddingInner?: number;
+  paddingOuter?: number;
+  align?: number;
 }
 
 export interface OffsetEncodingOptions {
@@ -2078,11 +3667,13 @@ export interface OffsetEncodingOptions {
 export interface XOffsetEncodingOptions extends OffsetEncodingOptions {}
 export interface YOffsetEncodingOptions extends OffsetEncodingOptions {}
 
-export type TextFormat = "auto" | `.${number}f`;
+export type TextFormat = ValueFormat;
 
 export interface TextMarkOptions {
   id?: string;
   data?: string;
+  /** Explicit source mark. Mutually exclusive with data; may be incomplete. */
+  source?: string;
   text?: unknown;
   fill?: string;
   opacity?: number;
@@ -2091,12 +3682,12 @@ export interface TextMarkOptions {
   fontWeight?: string | number;
   align?: "left" | "right" | "center" | "start" | "end";
   baseline?: "top" | "hanging" | "middle" | "alphabetic" | "ideographic" | "bottom";
-  rotation?: number;
+  rotation?: RotationInput;
   dx?: number;
   dy?: number;
 }
 
-export interface EditTextMarkOptions extends Omit<TextMarkOptions, "id" | "data" | "text"> {
+export interface EditTextMarkOptions extends Omit<TextMarkOptions, "id" | "data" | "source" | "text"> {
   target?: string;
 }
 
@@ -2110,6 +3701,27 @@ export interface LabelLeaderOptions {
   opacity?: number;
 }
 
+export type MarkLabelAnchor =
+  | "center"
+  | "insideStart"
+  | "insideEnd"
+  | "outsideStart"
+  | "outsideEnd";
+
+export interface MarkLabelPlacementLeaderOptions {
+  stroke?: string;
+  strokeWidth?: number;
+}
+
+export interface MarkLabelPlacement {
+  anchor: MarkLabelAnchor;
+  /** Pixel gap between the source boundary and the nearest text edge. Defaults to 4. */
+  gap?: number;
+  /** Inside-fit behavior. Defaults to hide. */
+  overflow?: "hide" | "outside" | "allow";
+  leader?: false | MarkLabelPlacementLeaderOptions;
+}
+
 export interface LabelLayoutOptions {
   target?: string;
   axis?: LabelLayoutAxis;
@@ -2123,7 +3735,7 @@ export interface RemoveLabelLayoutOptions {
   target?: string;
 }
 
-export interface RectMarkOptions {
+export interface RectMarkOptions extends RectStyleDetails {
   id?: string;
   data?: string;
   fill?: string;
@@ -2140,10 +3752,81 @@ export type TextEncodingOptions = {
   target?: string;
   format?: TextFormat;
 } & (
-  | { field: string; value?: never }
-  | { field?: never; value: unknown }
+  | { field: string; value?: never; content?: never; normalizeBy?: never }
+  | { field?: never; value: unknown; content?: never; normalizeBy?: never }
+  | { field?: never; value?: never; content: "category" | "value"; normalizeBy?: never }
+  | { field?: never; value?: never; content: "share"; normalizeBy?: "source" | "category" }
+);
+
+/** Attached final-item labels; lower text actions own subsequent edits. */
+export type MarkLabelSelectionOptions =
+  | { select?: never; selection?: never }
+  | { select: MarkSelector; selection?: never }
+  | { selection: string; select?: never };
+
+export type CreateMarkLabelsOptions = Omit<TextMarkOptions, "data" | "text"> & {
+  layout?: false | Omit<LabelLayoutOptions, "target">;
+  placement?: MarkLabelPlacement;
+} & (
+  | (TextEncodingOptions extends infer Options
+      ? Options extends TextEncodingOptions ? Omit<Options, "target"> : never
+      : never)
+  | { field?: never; value?: never; content?: never; normalizeBy?: never; format?: TextFormat }
+) & MarkLabelSelectionOptions;
+
+/** Replace the requested final-item membership of one attached label layer. */
+export type EditMarkLabelSelectionOptions = { target: string } & (
+  | { select: MarkSelector; selection?: never; all?: never }
+  | { selection: string; select?: never; all?: never }
+  | { all: true; select?: never; selection?: never }
 );
 
+/** Replace semantic placement or reset one attached label layer to its legacy anchor. */
+export interface EditMarkLabelPlacementOptions {
+  target: string;
+  placement: MarkLabelPlacement | "auto";
+}
+
+/** Remove one attached label layer or every attached label owned by a source mark. */
+export type RemoveMarkLabelsOptions =
+  | { target: string; source?: never }
+  | { source: string; target?: never };
+
+type AnnotationBaseOptions = Omit<TextMarkOptions, "id" | "data" | "source" | "text"> & {
+  id?: string;
+  text: unknown;
+  format?: TextFormat;
+  layout?: false | Omit<LabelLayoutOptions, "target">;
+};
+
+type AnnotationAnchor =
+  | {
+      x?: never;
+      y?: never;
+      space?: never;
+      source?: string;
+      data?: never;
+      coordinate?: never;
+    }
+  | {
+      x: unknown;
+      y: unknown;
+      space?: "data";
+      source?: string;
+      data?: never;
+      coordinate?: never;
+    }
+  | {
+      x: number;
+      y: number;
+      space: "plot";
+      source?: never;
+      data?: string;
+      coordinate?: string;
+    };
+
+export type CreateAnnotationOptions = AnnotationBaseOptions & AnnotationAnchor;
+
 export type BarWidthOptions = { target?: string } & (
   | { band?: number; pixels?: never }
   | { band?: never; pixels: number }
@@ -2173,7 +3856,7 @@ export type StrokeDashEncodingOptions =
     };
 
 export type NonPointContinuousColorScaleOptions = ScaleFields<
-  "id" | "interpolate" | "clamp" | "reverse"
+  "id" | "interpolate" | "midpoint" | "clamp" | "reverse"
 > & {
   type?: "sequential";
   domain?: "auto" | readonly [unknown, unknown];
@@ -2237,12 +3920,49 @@ export type ColorEncodingOptions =
       field: string;
       target?: string;
       fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
       aggregate?: never;
-      scale?: ContinuousColorScaleOptions;
+      scale?: Omit<ContinuousColorScaleOptions, "midpoint"> & { midpoint?: "auto" };
       palette?: Palette;
       layout?: never;
     };
 
+export type StrokeEncodingOptions =
+  | {
+      target?: string;
+      value: string;
+      field?: never;
+      fieldType?: never;
+      temporalUnit?: never;
+      scale?: never;
+    }
+  | {
+      target?: string;
+      field: string;
+      value?: never;
+      fieldType?: "nominal" | "ordinal";
+      temporalUnit?: never;
+      scale?: CategoricalColorScaleOptions;
+    }
+  | {
+      target?: string;
+      field: string;
+      value?: never;
+      fieldType: "quantitative";
+      temporalUnit?: never;
+      scale?: ContinuousColorScaleOptions | DiscretizedColorScaleOptions;
+    }
+  | {
+      target?: string;
+      field: string;
+      value?: never;
+      fieldType: "temporal";
+      temporalUnit?: TemporalInputUnit;
+      scale?: Omit<ContinuousColorScaleOptions, "midpoint"> & {
+        midpoint?: "auto";
+      };
+    };
+
 export type OpacityScaleOptions = ScaleFields<
   "id" | "nice" | "zero" | "clamp" | "reverse"
 > & {
@@ -2253,7 +3973,7 @@ export type OpacityScaleOptions = ScaleFields<
 };
 
 export type OpacityEncodingOptions =
-  | { value: number; field?: never; target?: string }
+  | { value: number; field?: never; target?: string; fieldType?: never; scale?: never }
   | {
       field: string;
       value?: never;
@@ -2264,6 +3984,48 @@ export type OpacityEncodingOptions =
 
 export type StrokeWidthScaleOptions = NonPointQuantitativePositionScaleOptions;
 
+export interface RuleStyleOptions extends StrokeStyleDetails {
+  stroke?: string;
+  strokeWidth?: number;
+  strokeDash?: DashStyle | DashPattern;
+  opacity?: number;
+}
+
+type ReferenceAxis<Value> = { x: Value; y?: never } | { y: Value; x?: never };
+type ReferenceBinding<DataValue, PlotValue> =
+  | ({ space?: "data"; source?: string; temporalUnit?: TemporalInputUnit;
+       data?: never; coordinate?: never } & ReferenceAxis<DataValue>)
+  | ({ space: "plot"; data?: string; coordinate?: string;
+       source?: never; temporalUnit?: never } & ReferenceAxis<PlotValue>);
+
+export type ReferenceStatistic =
+  | { readonly op: "mean" | "median" | "min" | "max"; readonly p?: never }
+  | { readonly op: "quantile"; readonly p: number };
+type DynamicReferenceBinding = {
+  readonly id?: string;
+  readonly source: string;
+  readonly axis: "x" | "y";
+  readonly population?: "boundData" | "visibleItems";
+  readonly field?: string;
+  readonly x?: never;
+  readonly y?: never;
+  readonly space?: never;
+  readonly data?: never;
+  readonly coordinate?: never;
+  readonly temporalUnit?: never;
+};
+export type CreateReferenceLineOptions =
+  | ({ id?: string } & RuleStyleOptions & ReferenceBinding<unknown, number>)
+  | (DynamicReferenceBinding & RuleStyleOptions & {
+      readonly statistic: ReferenceStatistic;
+    });
+export type CreateReferenceBandOptions =
+  | (Omit<RectMarkOptions, "data"> &
+      ReferenceBinding<readonly [unknown, unknown], readonly [number, number]>)
+  | (DynamicReferenceBinding & Omit<RectMarkOptions, "id" | "data" | "source"> & {
+      readonly statistics: readonly [ReferenceStatistic, ReferenceStatistic];
+    });
+
 export type StrokeWidthEncodingOptions =
   | {
       value: number;
@@ -2280,10 +4042,63 @@ export type StrokeWidthEncodingOptions =
       scale?: StrokeWidthScaleOptions;
     };
 
+export type SizeEncodingOptions = {
+  field: string;
+  target?: string;
+  fieldType?: "quantitative";
+  scale?: SizeScaleOptions;
+};
+
+export type ShapeEncodingOptions = {
+  field: string;
+  target?: string;
+  fieldType?: "nominal";
+  scale?: ShapeScaleOptions;
+};
+
+export type AngleEncodingOptions =
+  | { target?: string; value: number; field?: never; fieldType?: never }
+  | { target?: string; field: string; fieldType?: "quantitative"; value?: never };
+
+type WithoutEncodingTarget<T> = T extends unknown
+  ? Omit<T, "target" | "coordinate">
+  : never;
+
+export interface EncodingChannelAssignments {
+  x?: WithoutEncodingTarget<PositionEncodingOptions | DatumPositionEncodingOptions>;
+  y?: WithoutEncodingTarget<YPositionEncodingOptions | DatumPositionEncodingOptions>;
+  x2?: WithoutEncodingTarget<SecondaryPositionEncodingOptions>;
+  y2?: WithoutEncodingTarget<SecondaryPositionEncodingOptions>;
+  theta?: WithoutEncodingTarget<ThetaEncodingOptions>;
+  r?: WithoutEncodingTarget<RadialEncodingOptions>;
+  xOffset?: WithoutEncodingTarget<XOffsetEncodingOptions>;
+  yOffset?: WithoutEncodingTarget<YOffsetEncodingOptions>;
+  group?: WithoutEncodingTarget<GroupEncodingOptions>;
+  pathOrder?: WithoutEncodingTarget<PathOrderEncodingOptions>;
+  color?: WithoutEncodingTarget<ColorEncodingOptions>;
+  stroke?: WithoutEncodingTarget<StrokeEncodingOptions>;
+  size?: WithoutEncodingTarget<SizeEncodingOptions>;
+  shape?: WithoutEncodingTarget<ShapeEncodingOptions>;
+  opacity?: WithoutEncodingTarget<OpacityEncodingOptions>;
+  strokeWidth?: WithoutEncodingTarget<StrokeWidthEncodingOptions>;
+  strokeDash?: WithoutEncodingTarget<StrokeDashEncodingOptions>;
+  angle?: WithoutEncodingTarget<AngleEncodingOptions>;
+  text?: WithoutEncodingTarget<TextEncodingOptions>;
+}
+
+type AtLeastOne<T> = {
+  [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>
+}[keyof T];
+
+export interface EncodeChannelsOptions {
+  target: string;
+  channels: AtLeastOne<EncodingChannelAssignments>;
+}
+
 export type RegressionMethod = "linear" | "polynomial" | "loess";
 export type RegressionInterval = "mean" | "prediction";
 
-export interface RegressionBandOptions {
+export interface RegressionBandOptions extends StrokeStyleDetails {
   color?: string;
   opacity?: number;
   stroke?: string;
@@ -2291,7 +4106,7 @@ export interface RegressionBandOptions {
   curve?: CurveInterpolation;
 }
 
-export interface CreateRegressionBandOptions {
+export interface CreateRegressionBandOptions extends StrokeStyleDetails {
   id: string;
   data: string;
   x: string;
@@ -2308,7 +4123,7 @@ export interface CreateRegressionBandOptions {
   curve?: CurveInterpolation;
 }
 
-export interface CreateRegressionLineOptions {
+export interface CreateRegressionLineOptions extends StrokeStyleDetails {
   id: string;
   data: string;
   x: string;
@@ -2327,6 +4142,8 @@ type RegressionParameterOptions =
       method?: "linear";
       degree?: never;
       span?: never;
+      confidenceMethod?: ConfidenceIntervalMethod;
+      level?: number;
       confidence?: number;
       interval?: RegressionInterval;
     }
@@ -2334,6 +4151,8 @@ type RegressionParameterOptions =
       method: "polynomial";
       degree?: number;
       span?: never;
+      confidenceMethod?: ConfidenceIntervalMethod;
+      level?: number;
       confidence?: number;
       interval?: RegressionInterval;
     }
@@ -2341,6 +4160,8 @@ type RegressionParameterOptions =
       method: "loess";
       degree?: never;
       span?: number;
+      confidenceMethod?: never;
+      level?: never;
       confidence?: never;
       interval?: never;
     };
@@ -2357,8 +4178,8 @@ type RegressionCommonOptions = {
   target?: string;
   x?: string;
   y?: string;
-  groupBy?: string;
-  line?: { strokeWidth?: number; curve?: CurveInterpolation };
+  groupBy?: string | false;
+  line?: StrokeStyleDetails & { strokeWidth?: number; curve?: CurveInterpolation };
 };
 
 export type RegressionOptions = RegressionCommonOptions & (
@@ -2382,10 +4203,12 @@ export interface EditRegressionOptions {
   method?: RegressionMethod;
   degree?: number;
   span?: number;
+  confidenceMethod?: ConfidenceIntervalMethod;
+  level?: number;
   confidence?: number;
   interval?: RegressionInterval;
   band?: false | RegressionBandOptions;
-  line?: { strokeWidth?: number; curve?: CurveInterpolation };
+  line?: StrokeStyleDetails & { strokeWidth?: number; curve?: CurveInterpolation };
 }
 
 export interface RemoveAxisOptions {
@@ -2402,7 +4225,8 @@ export interface RemoveGridOptions {
 
 export interface RemoveLegendOptions {
   target?: string;
-  channels?: readonly ("color" | "strokeDash" | "strokeWidth" | "shape" | "size" | "opacity")[];
+  /** Remove selected content, including part of a combined categorical legend; omission removes every owned block. */
+  channels?: readonly ("color" | "stroke" | "strokeDash" | "strokeWidth" | "shape" | "size" | "opacity")[];
 }
 
 export interface RemoveMarkOptions {
@@ -2410,11 +4234,17 @@ export interface RemoveMarkOptions {
 }
 
 export interface LegendTextOptions {
+  /** Gap after the occupied sample slot: categorical color/interval default 8; series 10; size/width 12.
+   * Categorical slots include all recipe strokes and mapped shape extents.
+   * Size retains a minimum 32px slot. Width includes the widest line stroke.
+   * Opacity: visible circle-stroke gap, default 12 (inline 8). */
   offset?: number;
   color?: string;
   fontSize?: number;
   fontFamily?: string;
   fontWeight?: string | number;
+  /** Continuous numeric/temporal label format. Categorical legends accept auto only. */
+  format?: ValueFormat;
 }
 
 export interface LegendTitleStyleOptions {
@@ -2444,6 +4274,8 @@ export type LegendSymbolLayer =
 
 export type LegendSymbolRecipe =
   | "auto"
+  /** Sampled opacity uses a single point recipe; radius defaults to 7 and must be positive. */
+  | { type?: "point"; radius?: number; fill?: string; stroke?: string; strokeWidth?: number }
   | { length?: number; lineWidth?: number }
   | { width?: number; height?: number; stroke?: string; strokeWidth?: number }
   | { layers: readonly LegendSymbolLayer[] };
@@ -2455,42 +4287,99 @@ export interface LegendBorderOptions {
   background?: string;
 }
 
+type LegendValueOrder = "scale" | { values: readonly CategoryValue[]; channel?: never };
+type CartesianLegendOrder = LegendValueOrder | { channel: "x" | "y"; values?: never };
+export type LegendOrder = LegendValueOrder |
+  { channel: "x" | "y" | "theta"; values?: never };
+
 export interface LegendOptions {
+  /** Categorical, interval, size, or stroke-width layout. Defaults to edge; legacy-bottom is categorical and requires bottom position. */
+  layout?: "edge" | "legacy-bottom";
+  /** Categorical item order; preserves the appearance scale's assignments. */
+  order?: LegendOrder;
   target?: string;
-  channels?: readonly ("color" | "strokeDash" | "strokeWidth" | "shape" | "size" | "opacity")[];
+  /** Exact requested content; omission infers encoded point color/shape/size. Explicit subsets include size only when listed. */
+  channels?: readonly ("color" | "stroke" | "strokeDash" | "strokeWidth" | "shape" | "size" | "opacity")[];
   position?: "right" | "left" | "bottom" | "top";
+  /** Single top/bottom edge: align complete occupied bounds, including border strokes, to the plot. Side positions require center. */
   align?: "left" | "center" | "right";
+  /** Categorical sides require vertical (the default); horizontal edges default to horizontal. */
   direction?: "horizontal" | "vertical";
+  /** Categorical sides allow omission or 1; multiple columns require a horizontal edge. */
   columns?: number;
+  /** Single top/bottom edge: gap from the plot to the nearest occupied legend edge. */
   offset?: number;
   titlePosition?: "top" | "left";
   title?: string;
+  /** Exact ascending samples for continuous size, opacity, or stroke-width legends. Cannot be combined with count. */
+  values?: readonly number[];
   count?: number;
   gradient?: { length?: number; thickness?: number };
   symbol?: LegendSymbolRecipe;
   labels?: LegendTextOptions;
+  /** New categorical+size blocks share typography on every edge; retained standalone size styles remain independent. */
   titleStyle?: LegendTitleStyleOptions;
   itemGap?: number;
   border?: boolean | LegendBorderOptions;
 }
 
+export type LegendChannel = NonNullable<LegendOptions["channels"]>[number];
+
+export interface LegendBlockTextPatch {
+  fontSize?: number;
+  fontFamily?: string;
+  fontWeight?: string | number;
+  color?: string;
+}
+
+export interface LegendBlockSymbolPatch {
+  /** Point glyph area in square pixels. */
+  size?: number;
+  fill?: string;
+  stroke?: string;
+  strokeWidth?: number;
+  opacity?: number;
+}
+
+export interface EditLegendBlockOptions {
+  target: string;
+  channel: LegendChannel;
+  title?: string;
+  values?: readonly [number, ...number[]] | "auto";
+  count?: number;
+  order?: readonly CategoryValue[];
+  gap?: number;
+  text?: LegendBlockTextPatch;
+  symbol?: LegendBlockSymbolPatch;
+  labelMap?: DisplayLabelMap | "auto";
+}
+
 export interface EditLegendOptions
-  extends Omit<LegendOptions, "channels" | "title"> {
+  extends Omit<LegendOptions, "title" | "values"> {
+  /** Exact final content set for the whole target; omission preserves content. */
+  channels?: LegendOptions["channels"];
   title?: string | "auto" | false;
+  /** Replace exact samples, or reset them to the remembered automatic count. */
+  values?: readonly number[] | "auto";
 }
 
 export interface EditLegendLayoutOptions {
   target?: string;
+  layout?: "edge" | "legacy-bottom";
   position?: "right" | "left" | "bottom" | "top";
+  /** Single top/bottom edge: align complete occupied bounds, including border strokes, to the plot. Side positions require center. */
   align?: "left" | "center" | "right";
+  /** Categorical sides require vertical (the default); horizontal edges default to horizontal. */
   direction?: "horizontal" | "vertical";
+  /** Categorical sides allow omission or 1; multiple columns require a horizontal edge. */
   columns?: number;
+  /** Single top/bottom edge: gap from the plot to the nearest occupied legend edge. */
   offset?: number;
   titlePosition?: "top" | "left";
   itemGap?: number;
 }
 
-export interface EditLegendLabelsOptions extends LegendTitleStyleOptions {
+export interface EditLegendLabelsOptions extends LegendTextOptions {
   target?: string;
 }
 
@@ -2556,11 +4445,11 @@ export type CategoryOrder =
     };
 export type OrderCategoriesOptions = {
   target?: string;
-  channel: "x" | "y";
+  channel: "x" | "y" | "theta";
 } & CategoryOrder;
 export interface RemoveCategoryOrderOptions {
   target?: string;
-  channel: "x" | "y";
+  channel: "x" | "y" | "theta";
 }
 
 export interface TitleOptions {
@@ -2599,40 +4488,73 @@ export class ChartProgram {
 
   createCanvas(options?: CanvasOptions): ChartProgram;
   editCanvas(options: CanvasOptions): ChartProgram;
+  fitCanvas(options?: FitCanvasOptions): ChartProgram;
+  applyTheme(options: ApplyThemeOptions): ChartProgram;
+  removeTheme(): ChartProgram;
   createData(options: { id?: string; values: readonly unknown[] }): ChartProgram;
+  removeData(options: RemoveResourceOptions): ChartProgram;
+  removeScale(options: RemoveResourceOptions): ChartProgram;
+  removeCoordinate(options: RemoveResourceOptions): ChartProgram;
+  bindMarkData(options: BindMarkDataOptions): ChartProgram;
   filterData(options: FilterDataOptions): ChartProgram;
   filterMarks(options: FilterMarksOptions): ChartProgram;
+  removeMarkFilter(options?: RemoveMarkFilterOptions): ChartProgram;
   selectMarks(options: SelectMarksOptions): ChartProgram;
   editMarkSelection(options: EditMarkSelectionOptions): ChartProgram;
   removeMarkHighlight(options?: RemoveMarkSelectionOptions): ChartProgram;
   removeMarkSelection(options?: RemoveMarkSelectionOptions): ChartProgram;
   highlightMarks(options: HighlightMarksOptions): ChartProgram;
   createDensityData(options: DensityDataOptions): ChartProgram;
+  createSummaryData(options: SummaryDataOptions): ChartProgram;
+  createBinData(options: BinDataOptions): ChartProgram;
+  createFoldData(options: FoldDataOptions): ChartProgram;
+  createComputedData(options: ComputedDataOptions): ChartProgram;
+  createNormalizedData(options: NormalizedDataOptions): ChartProgram;
+  createCompleteData(options: CompleteDataOptions): ChartProgram;
+  createImputedData(options: ImputedDataOptions): ChartProgram;
+  createStackData(options: StackDataOptions): ChartProgram;
   createRegressionData(options: RegressionDataOptions): ChartProgram;
   createIntervalData(options: IntervalDataOptions): ChartProgram;
+  createECDFData(options: ECDFDataOptions): ChartProgram;
   createTimeUnitData(options: TimeUnitDataOptions): ChartProgram;
   createWindowData(options: WindowDataOptions): ChartProgram;
   createBin2DData(options: Bin2DDataOptions): ChartProgram;
+  editDerivedData(options: EditDerivedDataOptions): ChartProgram;
+  editComputedData(options: EditComputedDataOptions): ChartProgram;
+  editFilteredData(options: EditFilteredDataOptions): ChartProgram;
+  editFoldData(options: EditFoldDataOptions): ChartProgram;
+  editSummaryData(options: EditSummaryDataOptions): ChartProgram;
+  editBinData(options: EditBinDataOptions): ChartProgram;
+  editTimeUnitData(options: EditTimeUnitDataOptions): ChartProgram;
+  editWindowData(options: EditWindowDataOptions): ChartProgram;
+  editDensityData(options: EditDensityDataOptions): ChartProgram;
+  editStackData(options: EditStackDataOptions): ChartProgram;
+  editRegressionData(options: EditRegressionDataOptions): ChartProgram;
+  editIntervalData(options: EditIntervalDataOptions): ChartProgram;
+  editECDFData(options: EditECDFDataOptions): ChartProgram;
+  editNormalizedData(options: EditNormalizedDataOptions): ChartProgram;
+  editCompleteData(options: EditCompleteDataOptions): ChartProgram;
+  editImputedData(options: EditImputedDataOptions): ChartProgram;
   editBin2DData(options: EditBin2DDataOptions): ChartProgram;
 
-  createPointMark(options?: {
+  createPointMark(options?: StrokeStyleDetails & {
     id?: string;
     data?: string;
     shape?: PointShape;
     fill?: string;
     opacity?: number;
-    stroke?: string;
+    stroke?: FilledMarkStroke;
     strokeWidth?: number;
   }): ChartProgram;
-  editPointMark(options: {
+  editPointMark(options: StrokeStyleDetails & {
     target?: string;
     shape?: PointShape;
     fill?: string;
     opacity?: number;
-    stroke?: string | false;
+    stroke?: FilledMarkStroke;
     strokeWidth?: number;
   }): ChartProgram;
-  createTickMark(options?: {
+  createTickMark(options?: StrokeStyleDetails & {
     id?: string;
     data?: string;
     length?: number;
@@ -2640,7 +4562,7 @@ export class ChartProgram {
     strokeWidth?: number;
     opacity?: number;
   }): ChartProgram;
-  editTickMark(options: {
+  editTickMark(options: StrokeStyleDetails & {
     target?: string;
     length?: number;
     stroke?: string;
@@ -2649,7 +4571,9 @@ export class ChartProgram {
   }): ChartProgram;
   jitterPoints(options: JitterPointsOptions): ChartProgram;
   removeJitter(options?: RemoveJitterOptions): ChartProgram;
-  createLineMark(options?: {
+  packPoints(options: PackPointsOptions): ChartProgram;
+  removePointPacking(options?: RemovePointPackingOptions): ChartProgram;
+  createLineMark(options?: StrokeStyleDetails & {
     id?: string;
     data?: string;
     strokeWidth?: number;
@@ -2658,7 +4582,7 @@ export class ChartProgram {
     opacity?: number;
     closed?: boolean;
   }): ChartProgram;
-  editLineMark(options: {
+  editLineMark(options: StrokeStyleDetails & {
     target?: string;
     strokeWidth?: number;
     curve?: CurveInterpolation;
@@ -2666,22 +4590,22 @@ export class ChartProgram {
     opacity?: number;
     closed?: boolean;
   }): ChartProgram;
-  createBarMark(options?: {
+  createBarMark(options?: RectStyleDetails & {
     id?: string;
     data?: string;
     fill?: string;
     opacity?: number;
-    stroke?: string;
+    stroke?: FilledMarkStroke;
     strokeWidth?: number;
   }): ChartProgram;
-  editBarMark(options: {
+  editBarMark(options: RectStyleDetails & {
     target?: string;
     fill?: string;
     opacity?: number;
-    stroke?: string | false;
+    stroke?: FilledMarkStroke;
     strokeWidth?: number;
   }): ChartProgram;
-  createAreaMark(options?: {
+  createAreaMark(options?: StrokeStyleDetails & {
     id?: string;
     data?: string;
     fill?: string;
@@ -2689,8 +4613,9 @@ export class ChartProgram {
     stroke?: string;
     strokeWidth?: number;
     curve?: CurveInterpolation;
+    missing?: "error" | "break";
   }): ChartProgram;
-  createArcMark(options?: {
+  createArcMark(options?: StrokeStyleDetails & {
     id?: string;
     data?: string;
     innerRadius?: number;
@@ -2700,7 +4625,7 @@ export class ChartProgram {
     stroke?: string;
     strokeWidth?: number;
   }): ChartProgram;
-  editArcMark(options: {
+  editArcMark(options: StrokeStyleDetails & {
     target?: string;
     innerRadius?: number;
     padAngle?: number;
@@ -2711,33 +4636,39 @@ export class ChartProgram {
   }): ChartProgram;
   createRectMark(options?: RectMarkOptions): ChartProgram;
   editRectMark(options: EditRectMarkOptions): ChartProgram;
-  createRuleMark(options?: { id?: string; data?: string }): ChartProgram;
+  createRuleMark(options?: { id?: string; data?: string } & RuleStyleOptions): ChartProgram;
+  editRuleMark(options: { target?: string } & RuleStyleOptions): ChartProgram;
   createTextMark(options?: TextMarkOptions): ChartProgram;
+  createMarkLabels(options?: CreateMarkLabelsOptions): ChartProgram;
+  editMarkLabelSelection(options: EditMarkLabelSelectionOptions): ChartProgram;
+  editMarkLabelPlacement(options: EditMarkLabelPlacementOptions): ChartProgram;
+  removeMarkLabels(options: RemoveMarkLabelsOptions): ChartProgram;
+  createAnnotation(options: CreateAnnotationOptions): ChartProgram;
+  createReferenceLine(options: CreateReferenceLineOptions): ChartProgram;
+  createReferenceBand(options: CreateReferenceBandOptions): ChartProgram;
   editTextMark(options: EditTextMarkOptions): ChartProgram;
   layoutLabels(options?: LabelLayoutOptions): ChartProgram;
   removeLabelLayout(options?: RemoveLabelLayoutOptions): ChartProgram;
-  editAreaMark(options: {
+  editAreaMark(options: StrokeStyleDetails & {
     target?: string;
     fill?: string;
     opacity?: number;
     stroke?: string | false;
     strokeWidth?: number;
     curve?: CurveInterpolation;
+    missing?: "error" | "break";
   }): ChartProgram;
 
-  encodeX(options: PositionEncodingOptions | RulePositionEncodingOptions): ChartProgram;
-  encodeY(options: YPositionEncodingOptions | RulePositionEncodingOptions): ChartProgram;
+  encodeX(options: PositionEncodingOptions | DatumPositionEncodingOptions): ChartProgram;
+  encodeY(options: YPositionEncodingOptions | DatumPositionEncodingOptions): ChartProgram;
   encodeTheta(options: ThetaEncodingOptions): ChartProgram;
   encodeR(options: RadialEncodingOptions): ChartProgram;
   encodeX2(options: SecondaryPositionEncodingOptions): ChartProgram;
   encodeColor(options: ColorEncodingOptions): ChartProgram;
   encodeStrokeDash(options: StrokeDashEncodingOptions): ChartProgram;
-  encodeSize(options: { field: string; target?: string; fieldType?: "quantitative"; scale?: SizeScaleOptions }): ChartProgram;
-  encodeShape(options: { field: string; target?: string; fieldType?: "nominal"; scale?: ShapeScaleOptions }): ChartProgram;
-  encodeAngle(options:
-    | { target?: string; value: number; field?: never; fieldType?: never }
-    | { target?: string; field: string; fieldType?: "quantitative"; value?: never }
-  ): ChartProgram;
+  encodeSize(options: SizeEncodingOptions): ChartProgram;
+  encodeShape(options: ShapeEncodingOptions): ChartProgram;
+  encodeAngle(options: AngleEncodingOptions): ChartProgram;
   encodeOpacity(options: OpacityEncodingOptions): ChartProgram;
   encodeRadius(options: { value: number; target?: string }): ChartProgram;
   encodePointRadius(options: { value: number; target?: string }): ChartProgram;
@@ -2745,23 +4676,10 @@ export class ChartProgram {
   encodeXOffset(options: XOffsetEncodingOptions): ChartProgram;
   encodeYOffset(options: YOffsetEncodingOptions): ChartProgram;
   encodeY2(options: SecondaryPositionEncodingOptions): ChartProgram;
-  encodeYRange(options: {
-    lower: string;
-    upper: string;
-    target?: string;
-    fieldType?: "quantitative";
-    coordinate?: string;
-    scale?: NonPointQuantitativePositionScaleOptions;
-  }): ChartProgram;
-  encodeXRange(options: {
-    lower: string;
-    upper: string;
-    target?: string;
-    fieldType?: "quantitative";
-    coordinate?: string;
-    scale?: NonPointQuantitativePositionScaleOptions;
-  }): ChartProgram;
-  encodeGroup(options: { field: string; target?: string; fieldType?: "nominal" }): ChartProgram;
+  encodeYRange(options: RangePositionEncodingOptions): ChartProgram;
+  encodeXRange(options: RangePositionEncodingOptions): ChartProgram;
+  encodeGroup(options: GroupEncodingOptions): ChartProgram;
+  layoutSeries(options: SeriesLayoutOptions): ChartProgram;
   encodePathOrder(options: PathOrderEncodingOptions): ChartProgram;
   orderCategories(options: OrderCategoriesOptions): ChartProgram;
   encodeParallelCoordinates(options: ParallelCoordinatesEncodingOptions): ChartProgram;
@@ -2771,7 +4689,7 @@ export class ChartProgram {
     target?: string;
     channel:
       | "x" | "y" | "x2" | "y2" | "xOffset" | "yOffset"
-      | "theta" | "radius" | "color" | "strokeDash" | "strokeWidth"
+      | "theta" | "radius" | "color" | "stroke" | "strokeDash" | "strokeWidth"
       | "size" | "shape" | "angle" | "group" | "opacity" | "text";
   }): ChartProgram;
   encodeText(options: TextEncodingOptions): ChartProgram;
@@ -2781,8 +4699,9 @@ export class ChartProgram {
   encodeHorizon(options?: HorizonEncodingOptions): ChartProgram;
   editHorizon(options: EditHorizonOptions): ChartProgram;
   encodeBarWidth(options?: BarWidthOptions): ChartProgram;
-  encodeStroke(options: { target?: string; value: string }): ChartProgram;
+  encodeStroke(options: StrokeEncodingOptions): ChartProgram;
   encodeStrokeWidth(options: StrokeWidthEncodingOptions): ChartProgram;
+  encodeChannels(options: EncodeChannelsOptions): ChartProgram;
 
   createRegression(options?: RegressionOptions): ChartProgram;
   editRegression(options: EditRegressionOptions): ChartProgram;
@@ -2796,23 +4715,59 @@ export class ChartProgram {
   createGradientPlot(options?: GradientPlotOptions): ChartProgram;
   editGradientPlot(options: EditGradientPlotOptions): ChartProgram;
   createViolinPlot(options: ViolinPlotOptions): ChartProgram;
+  editViolinPlot(options: EditViolinPlotOptions): ChartProgram;
   createScatterPlot(options: CreateScatterPlotOptions): ChartProgram;
+  createIntervalPlot(options: CreateIntervalPlotOptions): ChartProgram;
+  createRegressionPlot(options: CreateRegressionPlotOptions): ChartProgram;
+  createDotPlot(options: CreateDotPlotOptions): ChartProgram;
+  createLollipopPlot(options: CreateLollipopPlotOptions): ChartProgram;
+  createDumbbellPlot(options: CreateDumbbellPlotOptions): ChartProgram;
+  editEndpointPlot(options: EditEndpointPlotOptions): ChartProgram;
+  createECDFPlot(options: CreateECDFPlotOptions): ChartProgram;
+  editECDFPlot(options: EditECDFPlotOptions): ChartProgram;
   createLinePlot(options: CreateLinePlotOptions): ChartProgram;
+  createPolarScatterPlot(options: CreatePolarScatterPlotOptions): ChartProgram;
+  createPolarLinePlot(options: CreatePolarLinePlotOptions): ChartProgram;
+  createRadarPlot(options: CreateRadarPlotOptions): ChartProgram;
+  createRugPlot(options: CreateRugPlotOptions): ChartProgram;
+  createStripPlot(options: CreateStripPlotOptions): ChartProgram;
+  createBeeswarmPlot(options: CreateBeeswarmPlotOptions): ChartProgram;
+  createRaincloudPlot(options: CreateRaincloudPlotOptions): ChartProgram;
+  editRaincloudPlot(options: EditRaincloudPlotOptions): ChartProgram;
+  createAreaPlot(options: CreateAreaPlotOptions): ChartProgram;
   createBarPlot(options: CreateBarPlotOptions): ChartProgram;
   createHistogram(options: CreateHistogramOptions): ChartProgram;
+  createPiePlot(options: CreatePiePlotOptions): ChartProgram;
+  createRosePlot(options: CreateRosePlotOptions): ChartProgram;
+  createRadialBarPlot(options: CreateRadialBarPlotOptions): ChartProgram;
+  createDensityPlot(options: CreateDensityPlotOptions): ChartProgram;
+  createHorizonPlot(options: CreateHorizonPlotOptions): ChartProgram;
   createHeatmap(options: CreateHeatmapOptions): ChartProgram;
   createParallelCoordinates(options: CreateParallelCoordinatesOptions): ChartProgram;
   removeMark(options?: RemoveMarkOptions): ChartProgram;
+  createParallelAxes(options?: ParallelAxesOptions): ChartProgram;
+  createParallelAxis(options: CreateParallelAxisOptions): ChartProgram;
+  editParallelAxis(options: EditParallelAxisOptions): ChartProgram;
+  removeParallelAxis(options: RemoveParallelAxisOptions): ChartProgram;
+  removeParallelAxes(options?: ParallelAxesOptions): ChartProgram;
   createAxes(options?: CreateAxesOptions): ChartProgram;
   createXAxis(options?: CompleteAxisOptions<XAxisPosition>): ChartProgram;
   createYAxis(options?: CompleteAxisOptions<YAxisPosition>): ChartProgram;
-  createThetaAxis(options?: CompletePolarAxisOptions): ChartProgram;
+  createThetaAxis(options?: CompleteThetaAxisOptions): ChartProgram;
   createRadialAxis(options?: CompleteRadialAxisOptions): ChartProgram;
+  createThetaAxisLine(options?: CreateThetaAxisLineOptions): ChartProgram;
+  createRadialAxisLine(options?: CreateRadialAxisLineOptions): ChartProgram;
+  createThetaAxisTicks(options?: CreateThetaAxisTicksOptions): ChartProgram;
+  createRadialAxisTicks(options?: CreateRadialAxisTicksOptions): ChartProgram;
+  createThetaAxisLabels(options?: CreateThetaAxisLabelsOptions): ChartProgram;
+  createRadialAxisLabels(options?: CreateRadialAxisLabelsOptions): ChartProgram;
+  createThetaAxisTitle(options?: CreateThetaAxisTitleOptions): ChartProgram;
+  createRadialAxisTitle(options?: CreateRadialAxisTitleOptions): ChartProgram;
   editThetaAxisLine(options?: AxisLineStyleOptions): ChartProgram;
   editRadialAxisLine(options?: AxisLineStyleOptions): ChartProgram;
   editThetaAxisTicks(options?: PolarTickOptions): ChartProgram;
   editRadialAxisTicks(options?: PolarTickOptions): ChartProgram;
-  editThetaAxisLabels(options?: PolarLabelOptions): ChartProgram;
+  editThetaAxisLabels(options?: ThetaAxisLabelOptions): ChartProgram;
   editRadialAxisLabels(options?: PolarLabelOptions): ChartProgram;
   editThetaAxisTitle(options?: PolarTitleOptions): ChartProgram;
   editRadialAxisTitle(options?: RadialTitleOptions): ChartProgram;
@@ -2838,7 +4793,7 @@ export class ChartProgram {
   editYAxisTitle(options?: Omit<AxisTitleOptions<YAxisPosition>, "scale">): ChartProgram;
   editXAxis(options: EditAxisOptions<XAxisPosition>): ChartProgram;
   editYAxis(options: EditAxisOptions<YAxisPosition>): ChartProgram;
-  editThetaAxis(options: Omit<EditPolarAxisOptions, "angle">): ChartProgram;
+  editThetaAxis(options: EditThetaAxisOptions): ChartProgram;
   editRadialAxis(options: EditRadialAxisOptions): ChartProgram;
   removeXAxis(options?: RemoveAxisOptions): ChartProgram;
   removeYAxis(options?: RemoveAxisOptions): ChartProgram;
@@ -2855,8 +4810,10 @@ export class ChartProgram {
   editRadialGrid(options: EditPolarGridOptions): ChartProgram;
   editGrid(options: EditGridDirectionsOptions): ChartProgram;
   removeGrid(options?: RemoveGridOptions): ChartProgram;
+  /** Combined categorical and size legends support all four edges with layout "edge". */
   createLegend(options?: LegendOptions): ChartProgram;
   editLegend(options: EditLegendOptions): ChartProgram;
+  editLegendBlock(options: EditLegendBlockOptions): ChartProgram;
   editLegendLayout(options: EditLegendLayoutOptions): ChartProgram;
   editLegendLabels(options: EditLegendLabelsOptions): ChartProgram;
   editLegendTitle(options: EditLegendTitleOptions): ChartProgram;
@@ -2869,11 +4826,26 @@ export class ChartProgram {
   removeTitle(): ChartProgram;
 
   createCoordinate(options?: CreateCoordinateOptions): ChartProgram;
+  editCoordinate(options: EditCoordinateOptions): ChartProgram;
   createScale(options: CreateScaleOptions): ChartProgram;
   editScale(options: EditScaleOptions): ChartProgram;
+  editXScale(options: EditXScaleOptions): ChartProgram;
+  editYScale(options: EditYScaleOptions): ChartProgram;
+  editXOffsetScale(options: EditXOffsetScaleOptions): ChartProgram;
+  editYOffsetScale(options: EditYOffsetScaleOptions): ChartProgram;
+  editParallelScale(options: EditParallelScaleOptions): ChartProgram;
+  editThetaScale(options: EditThetaScaleOptions): ChartProgram;
+  editRScale(options: EditRScaleOptions): ChartProgram;
+  editColorScale(options: EditColorScaleOptions): ChartProgram;
+  editStrokeScale(options: EditStrokeScaleOptions): ChartProgram;
+  editSizeScale(options: EditSizeScaleOptions): ChartProgram;
+  editOpacityScale(options: EditOpacityScaleOptions): ChartProgram;
+  editShapeScale(options: EditShapeScaleOptions): ChartProgram;
+  editStrokeWidthScale(options: EditStrokeWidthScaleOptions): ChartProgram;
+  editStrokeDashScale(options: EditStrokeDashScaleOptions): ChartProgram;
   createDerivedData(options: CreateDerivedDataOptions): ChartProgram;
   createRegressionBand(options: CreateRegressionBandOptions): ChartProgram;
-  editRegressionBand(options: {
+  editRegressionBand(options: StrokeStyleDetails & {
     target?: string;
     color?: string;
     opacity?: number;
@@ -2882,7 +4854,7 @@ export class ChartProgram {
     curve?: CurveInterpolation;
   }): ChartProgram;
   createRegressionLine(options: CreateRegressionLineOptions): ChartProgram;
-  editRegressionLine(options: {
+  editRegressionLine(options: StrokeStyleDetails & {
     target?: string;
     strokeWidth?: number;
     curve?: CurveInterpolation;
@@ -2890,7 +4862,13 @@ export class ChartProgram {
 
   editCompositionLayout(options: EditCompositionLayoutOptions): ChartProgram;
   replaceCompositionChild(options: ReplaceCompositionChildOptions): ChartProgram;
+  insertCompositionChild(options: InsertCompositionChildOptions): ChartProgram;
+  removeCompositionChild(options: RemoveCompositionChildOptions): ChartProgram;
+  reorderCompositionChildren(options: ReorderCompositionChildrenOptions): ChartProgram;
   facet(options: FacetOptions): ChartProgram;
+  facetGrid(options: FacetGridOptions): ChartProgram;
+  repeatCharts(options: RepeatChartsOptions): ChartProgram;
+  editFacetSource(options: EditFacetSourceOptions): ChartProgram;
   editFacetScales(options: FacetScaleResolutions): ChartProgram;
   editFacetGuides(options: FacetGuideOptions): ChartProgram;
   editFacetHeaders(options: EditFacetHeadersOptions): ChartProgram;