ggaction 0.0.3 → 0.0.5

package/types/program.d.ts

@@ -20,6 +20,25 @@ export type ConcretePathCommand =
       readonly y: number;
     }
   | { readonly op: "Z" };
+export interface LinearGradientPoint {
+  readonly x: number;
+  readonly y: number;
+}
+export interface LinearGradientStop {
+  readonly offset: number;
+  readonly color: string;
+}
+export interface LinearGradientPaint {
+  readonly type: "linear-gradient";
+  readonly from: LinearGradientPoint;
+  readonly to: LinearGradientPoint;
+  readonly stops: readonly [
+    LinearGradientStop,
+    LinearGradientStop,
+    ...LinearGradientStop[]
+  ];
+}
+export type FillPaint = string | LinearGradientPaint;
 export type CurveInterpolation =
   | "linear"
   | "step"
@@ -31,6 +50,19 @@ export type CurveInterpolation =
   | "natural";
 export type DashStyle = "solid" | "dashed" | "dotted" | "dashdot";
 export type DashPattern = readonly number[];
+export type JitterMaxOffset =
+  | { pixels: number; band?: never }
+  | { pixels?: never; band: number };
+export interface JitterPointsOptions {
+  target?: string;
+  channel: "x" | "y";
+  maxOffset: JitterMaxOffset;
+  seed?: string | number;
+  key?: string;
+}
+export interface RemoveJitterOptions {
+  target?: string;
+}
 export type ScaleType =
   | "linear"
   | "log"
@@ -140,6 +172,34 @@ export type DensityKernel =
   | "uniform"
   | "triangular";
 export type DensityNormalization = "unit" | "count";
+export type DensityPlacementSide =
+  | "both"
+  | "left"
+  | "right"
+  | "top"
+  | "bottom";
+export type DensityWidthResolution = "shared" | "independent";
+export interface DensityPlacementWidth {
+  band?: number;
+  resolve?: DensityWidthResolution;
+}
+export interface DensityPlacementSplit {
+  field: string;
+  domain?: readonly [unknown, unknown];
+}
+export interface BaselineDensityPlacement {
+  type: "baseline";
+}
+export interface CategoryDensityPlacement {
+  type: "category";
+  side?: DensityPlacementSide;
+  width?: DensityPlacementWidth;
+  split?: DensityPlacementSplit;
+  scale?: ScaleOptions;
+}
+export type DensityPlacement =
+  | BaselineDensityPlacement
+  | CategoryDensityPlacement;
 export type FilterComparison =
   | { op: "eq" | "neq"; value: unknown }
   | { op: "lt" | "lte" | "gt" | "gte"; value: number | string };
@@ -205,9 +265,67 @@ export interface DatasetDensityTransform {
   normalization?: DensityNormalization;
   as: readonly [string, string];
   resolve: "shared";
+  placement?: {
+    readonly type: "category";
+    readonly channel: "x" | "y";
+    readonly categoryField: string;
+    readonly side: DensityPlacementSide;
+    readonly width: {
+      readonly band: number;
+      readonly resolve: DensityWidthResolution;
+    };
+    readonly split?: {
+      readonly field: string;
+      readonly domain?: readonly [unknown, unknown];
+    };
+  };
   resolved?: {
     readonly bandwidth: number;
     readonly extent: readonly [number, number];
+    readonly splitDomain?: readonly [unknown, unknown];
+  };
+}
+export type HorizonResolution = "shared" | "independent";
+export type HorizonMissingPolicy = "break" | "error";
+export type HorizonOverflowPolicy = "clip" | "error";
+export interface HorizonOutputFields {
+  readonly x: string;
+  readonly lower: string;
+  readonly upper: string;
+  readonly group: string;
+  readonly color: string;
+  readonly sign: string;
+  readonly band: string;
+  readonly segment: string;
+}
+export interface DatasetHorizonTransform {
+  readonly type: "horizon";
+  readonly x: {
+    readonly field: string;
+    readonly fieldType: "quantitative" | "temporal";
+  };
+  readonly y: {
+    readonly field: string;
+    readonly fieldType: "quantitative";
+  };
+  readonly groupBy?: string;
+  readonly bands: number;
+  readonly baseline: number;
+  readonly extent: "auto" | number;
+  readonly resolve: HorizonResolution;
+  readonly missing: HorizonMissingPolicy;
+  readonly overflow: HorizonOverflowPolicy;
+  readonly palette: {
+    readonly positive: Readonly<Exclude<Palette, string>>;
+    readonly negative: Readonly<Exclude<Palette, string>>;
+  };
+  readonly as: HorizonOutputFields;
+  readonly resolved?: {
+    readonly extents: readonly {
+      readonly group?: DatasetScalar;
+      readonly extent: number;
+      readonly bandHeight: number;
+    }[];
   };
 }
 export interface DatasetIntervalOutputFields {
@@ -237,15 +355,106 @@ export type DatasetIntervalTransform = {
       level?: never;
     }
 );
+export type WindowSortOrder = "ascending" | "descending";
+export interface WindowSort {
+  field: string;
+  order?: WindowSortOrder;
+}
+export type WindowOperation =
+  | { op: "rowNumber" | "rank" | "denseRank"; as: string }
+  | { op: "cumulativeSum"; field: string; as: string }
+  | {
+      op: "lag" | "lead";
+      field: string;
+      as: string;
+      offset?: number;
+      default?: unknown;
+    };
+export interface DatasetWindowSort {
+  readonly field: string;
+  readonly order: WindowSortOrder;
+}
+export type DatasetWindowOperation =
+  | { readonly op: "rowNumber" | "rank" | "denseRank"; readonly as: string }
+  | {
+      readonly op: "cumulativeSum";
+      readonly field: string;
+      readonly as: string;
+    }
+  | {
+      readonly op: "lag" | "lead";
+      readonly field: string;
+      readonly as: string;
+      readonly offset: number;
+      readonly default: unknown;
+    };
+export interface DatasetWindowTransform {
+  readonly type: "window";
+  readonly partitionBy: readonly string[];
+  readonly sortBy: readonly DatasetWindowSort[];
+  readonly operations: readonly DatasetWindowOperation[];
+}
+export interface Bin2DCounts {
+  x: number;
+  y: number;
+}
+export interface Bin2DExtent {
+  x?: readonly [number, number];
+  y?: readonly [number, number];
+}
+export interface Bin2DOutputFields {
+  x0?: string;
+  x1?: string;
+  y0?: string;
+  y1?: string;
+  count?: string;
+  members?: string;
+}
+export interface DatasetBin2DOutputFields {
+  readonly x0: string;
+  readonly x1: string;
+  readonly y0: string;
+  readonly y1: string;
+  readonly count: string;
+  readonly members?: string;
+}
+export interface DatasetBin2DTransform {
+  readonly type: "bin2d";
+  readonly x: string;
+  readonly y: string;
+  readonly bins: Readonly<Bin2DCounts>;
+  readonly extent: {
+    readonly x: "auto" | readonly [number, number];
+    readonly y: "auto" | readonly [number, number];
+  };
+  readonly includeEmpty: boolean;
+  readonly members: boolean;
+  readonly as: DatasetBin2DOutputFields;
+  readonly resolved?: {
+    readonly extent: {
+      readonly x: readonly [number, number];
+      readonly y: readonly [number, number];
+    };
+    readonly edges: {
+      readonly x: readonly number[];
+      readonly y: readonly number[];
+    };
+    readonly eligibleCount: number;
+    readonly occupiedCount: number;
+  };
+}
 export type DatasetTransform =
+  | DatasetBin2DTransform
   | DatasetFilterTransform
   | DatasetRegressionTransform
   | DatasetDensityTransform
-  | DatasetIntervalTransform;
+  | DatasetHorizonTransform
+  | DatasetIntervalTransform
+  | DatasetWindowTransform;
 export interface CreateDerivedDataOptions {
   id: string;
   source: string;
-  transform: readonly [DatasetTransform, ...DatasetTransform[]];
+  transform: readonly [DatasetTransform];
 }
 export type MarkGraphicProperty =
   | "x" | "y" | "width" | "height" | "radius"
@@ -509,7 +718,7 @@ export interface CompleteAxisOptions<P extends string> {
 export interface CreateAxesOptions {
   coordinate?: {
     id?: string;
-    type?: "auto" | "cartesian" | "polar";
+    type?: "auto" | "cartesian" | "polar" | "parallel";
   };
   x?: false | CompleteAxisOptions<XAxisPosition>;
   y?: false | CompleteAxisOptions<YAxisPosition>;
@@ -636,7 +845,7 @@ export interface CreateGuidesOptions {
 
 export interface CreateCoordinateOptions {
   id?: string;
-  type?: "cartesian" | "polar";
+  type?: "cartesian" | "polar" | "parallel";
   layers?: readonly string[];
 }
 
@@ -739,7 +948,8 @@ export interface ThetaEncodingOptions {
   fieldType?: FieldType;
   scale?: ThetaScaleOptions;
   coordinate?: string;
-  aggregate?: "count";
+  aggregate?: "count" | "sum";
+  weight?: string;
 }
 
 export interface RadialEncodingOptions {
@@ -811,13 +1021,59 @@ export interface DensityDataOptions {
   as?: readonly [string, string];
 }
 
-export interface DensityEncodingOptions
-  extends Omit<DensityDataOptions, "id"> {
+type DensityEncodingBase = Omit<DensityDataOptions, "id"> & {
   target?: string;
   densityChannel?: "x" | "y";
   coordinate?: string;
   valueScale?: ScaleOptions;
-  densityScale?: ScaleOptions;
+};
+
+export type DensityEncodingOptions = DensityEncodingBase & (
+  | {
+      placement?: BaselineDensityPlacement;
+      densityScale?: ScaleOptions;
+    }
+  | {
+      placement: CategoryDensityPlacement;
+      densityScale?: never;
+    }
+);
+
+export interface HorizonXEncoding {
+  field: string;
+  fieldType?: "quantitative" | "temporal";
+  scale?: ScaleOptions;
+}
+
+export interface HorizonYEncoding {
+  field: string;
+  fieldType?: "quantitative";
+  scale?: ScaleOptions;
+}
+
+export interface HorizonPaletteOptions {
+  positive?: Palette;
+  negative?: Palette;
+}
+
+export interface HorizonEncodingOptions {
+  target?: string;
+  source?: string;
+  x?: string | HorizonXEncoding;
+  y?: string | HorizonYEncoding;
+  groupBy?: string;
+  bands?: number;
+  baseline?: number;
+  extent?: "auto" | number;
+  resolve?: HorizonResolution;
+  missing?: HorizonMissingPolicy;
+  overflow?: HorizonOverflowPolicy;
+  palette?: HorizonPaletteOptions;
+}
+
+export interface EditHorizonOptions
+  extends Omit<HorizonEncodingOptions, "groupBy"> {
+  groupBy?: string | false;
 }
 
 export type IntervalCenter = "mean" | "median";
@@ -840,6 +1096,26 @@ export interface IntervalDataOptions {
   as?: IntervalOutputFields;
 }
 
+export interface WindowDataOptions {
+  id: string;
+  source?: string;
+  partitionBy?: string | readonly string[];
+  sortBy?: readonly WindowSort[];
+  operations: readonly WindowOperation[];
+}
+
+export interface Bin2DDataOptions {
+  id: string;
+  source?: string;
+  x: string;
+  y: string;
+  bins?: number | Bin2DCounts;
+  extent?: Bin2DExtent;
+  includeEmpty?: boolean;
+  members?: boolean;
+  as?: Bin2DOutputFields;
+}
+
 export interface ErrorBarPositionChannel {
   field?: string;
   fieldType?: "nominal" | "ordinal" | "temporal";
@@ -936,6 +1212,7 @@ export interface BoxPlotOptions {
     radius?: number;
     opacity?: number;
   };
+  guides?: false | CreateGuidesOptions;
 }
 
 export interface EditBoxPlotOptions {
@@ -960,6 +1237,266 @@ export interface EditBoxPlotOptions {
   };
 }
 
+export type GradientPlotPositionChannel = BoxPlotPositionChannel;
+
+export interface GradientPlotDensityOptions {
+  bandwidth?: "auto" | number;
+  extent?: "auto" | readonly [number, number];
+  steps?: number;
+  kernel?: DensityKernel;
+  normalization?: DensityNormalization;
+}
+
+export interface GradientPlotAppearanceOptions {
+  palette?: Palette;
+  opacity?: readonly [number, number];
+}
+
+export interface GradientPlotCenterOptions {
+  type?: "mean" | "median";
+  stroke?: string;
+  strokeWidth?: number;
+}
+
+export interface GradientPlotOptions {
+  id?: string;
+  target?: string;
+  data?: string;
+  x?: GradientPlotPositionChannel;
+  y?: GradientPlotPositionChannel;
+  coordinate?: string;
+  density?: GradientPlotDensityOptions;
+  width?: { band?: number };
+  gradient?: GradientPlotAppearanceOptions;
+  center?: false | GradientPlotCenterOptions;
+  guides?: false | CreateGuidesOptions;
+}
+
+export type ViolinPlotPositionChannel =
+  | string
+  | BoxPlotPositionChannel;
+
+export interface ViolinPlotDensityOptions
+  extends GradientPlotDensityOptions {
+  width?: DensityPlacementWidth;
+}
+
+export interface ViolinPlotSplitOptions {
+  field: string;
+  domain?: readonly [unknown, unknown];
+}
+
+export type ViolinPlotColorOptions =
+  | string
+  | Omit<CategoricalEncodingOptions, "target">;
+
+export interface ViolinPlotAreaOptions {
+  fill?: string;
+  opacity?: number;
+  stroke?: string;
+  strokeWidth?: number;
+  curve?: CurveInterpolation;
+}
+
+export interface ViolinPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  x: ViolinPlotPositionChannel;
+  y: ViolinPlotPositionChannel;
+  split?: ViolinPlotSplitOptions;
+  color?: ViolinPlotColorOptions;
+  density?: ViolinPlotDensityOptions;
+  area?: ViolinPlotAreaOptions;
+  guides?: false | CreateGuidesOptions;
+}
+
+export interface EditGradientPlotOptions {
+  target?: string;
+  density?: GradientPlotDensityOptions;
+  width?: { band?: number };
+  gradient?: GradientPlotAppearanceOptions;
+  center?: false | GradientPlotCenterOptions;
+}
+
+type BasicPositionChannel =
+  | string
+  | Omit<PositionEncodingOptions, "target" | "coordinate">;
+type BasicColorChannel =
+  | string
+  | (ColorEncodingOptions extends infer T
+      ? T extends unknown ? Omit<T, "target"> : never
+      : never);
+export type BasicSizeChannel = string | {
+  field: string;
+  fieldType?: "quantitative";
+  scale?: ScaleOptions;
+};
+export type BasicShapeChannel = string | {
+  field: string;
+  fieldType?: "nominal";
+  scale?: ScaleOptions;
+};
+export type BasicStrokeDashChannel =
+  StrokeDashEncodingOptions extends infer T
+    ? T extends unknown ? Omit<T, "target"> : never
+    : never;
+
+export type ParallelMissingPolicy = "break" | "drop-row" | "error";
+export type ParallelDimension = string | {
+  field: string;
+  fieldType?: "quantitative" | "ordinal";
+  title?: string;
+  scale?: Omit<ScaleOptions, "id">;
+};
+export interface ParallelCoordinatesEncodingOptions {
+  target?: string;
+  coordinate?: string;
+  dimensions: readonly [ParallelDimension, ParallelDimension, ...ParallelDimension[]];
+  key?: string;
+  missing?: ParallelMissingPolicy;
+}
+export interface CreateParallelCoordinatesOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  dimensions: readonly [ParallelDimension, ParallelDimension, ...ParallelDimension[]];
+  key?: string;
+  missing?: ParallelMissingPolicy;
+  color?: BasicColorChannel;
+  strokeDash?: BasicStrokeDashChannel;
+  line?: {
+    strokeWidth?: number;
+    stroke?: string;
+    opacity?: number;
+    curve?: "linear";
+    closed?: false;
+  };
+  guides?: false | CreateGuidesOptions;
+}
+
+export interface CreateScatterPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  x: BasicPositionChannel;
+  y: BasicPositionChannel;
+  color?: BasicColorChannel;
+  size?: BasicSizeChannel;
+  shape?: BasicShapeChannel;
+  point?: {
+    shape?: PointShape;
+    fill?: string;
+    opacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+  };
+  guides?: false | CreateGuidesOptions;
+}
+
+export interface CreateLinePlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  x: BasicPositionChannel;
+  y: BasicPositionChannel;
+  color?: BasicColorChannel;
+  groupBy?: string;
+  strokeDash?: BasicStrokeDashChannel;
+  line?: {
+    strokeWidth?: number;
+    curve?: CurveInterpolation;
+    stroke?: string;
+    opacity?: number;
+    closed?: boolean;
+  };
+  guides?: false | CreateGuidesOptions;
+}
+
+type BasicHistogramEncoding =
+  HistogramEncodingOptions extends infer T
+    ? T extends unknown ? Omit<T, "field" | "target" | "coordinate"> : never
+    : never;
+
+export interface CreateBarPlotOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  x: BasicPositionChannel;
+  y: BasicPositionChannel;
+  color?: BasicColorChannel;
+  width?: Omit<BarWidthOptions, "target">;
+  bar?: {
+    fill?: string;
+    opacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+  };
+  guides?: false | CreateGuidesOptions;
+}
+
+export type CreateHistogramOptions = BasicHistogramEncoding & {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  field: string;
+  color?: BasicColorChannel;
+  bar?: {
+    fill?: string;
+    opacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+  };
+  guides?: false | CreateGuidesOptions;
+};
+
+export interface HeatmapBaseOptions {
+  id?: string;
+  data?: string;
+  coordinate?: string;
+  rect?: {
+    opacity?: number;
+    stroke?: string | false;
+    strokeWidth?: number;
+  };
+  guides?: false | CreateGuidesOptions;
+}
+
+export interface PreGriddedHeatmapOptions extends HeatmapBaseOptions {
+  x: BasicPositionChannel;
+  y: BasicPositionChannel;
+  bin?: never;
+  color: BasicColorChannel;
+}
+
+export interface BinnedHeatmapPositionChannel {
+  field: string;
+  fieldType?: "quantitative";
+  scale?: ScaleOptions;
+}
+
+export interface BinnedHeatmapColorOptions {
+  scale?: ContinuousColorScaleOptions | DiscretizedColorScaleOptions;
+  palette?: Palette;
+}
+
+export interface HeatmapBinOptions {
+  bins?: number | Bin2DCounts;
+  extent?: Bin2DExtent;
+  includeEmpty?: boolean;
+}
+
+export interface BinnedHeatmapOptions extends HeatmapBaseOptions {
+  x: string | BinnedHeatmapPositionChannel;
+  y: string | BinnedHeatmapPositionChannel;
+  bin: HeatmapBinOptions;
+  color?: BinnedHeatmapColorOptions;
+}
+
+export type CreateHeatmapOptions =
+  | PreGriddedHeatmapOptions
+  | BinnedHeatmapOptions;
+
 export interface ErrorBandPositionChannel {
   field?: string;
   fieldType?: "quantitative" | "temporal";
@@ -1029,6 +1566,7 @@ export interface EditDensityOptions {
   steps?: number;
   kernel?: DensityKernel;
   normalization?: DensityNormalization;
+  placement?: DensityPlacement;
 }
 
 export interface OffsetScaleOptions {
@@ -1072,6 +1610,29 @@ export interface EditTextMarkOptions extends Omit<TextMarkOptions, "id" | "data"
   target?: string;
 }
 
+export type LabelLayoutAxis = "x" | "y" | "both";
+export type LabelLayoutBounds = "plot" | "canvas";
+
+export interface LabelLeaderOptions {
+  stroke?: string;
+  strokeWidth?: number;
+  strokeDash?: readonly number[];
+  opacity?: number;
+}
+
+export interface LabelLayoutOptions {
+  target?: string;
+  axis?: LabelLayoutAxis;
+  padding?: number;
+  maxDisplacement?: number;
+  bounds?: LabelLayoutBounds;
+  leader?: false | LabelLeaderOptions;
+}
+
+export interface RemoveLabelLayoutOptions {
+  target?: string;
+}
+
 export interface RectMarkOptions {
   id?: string;
   data?: string;
@@ -1204,6 +1765,36 @@ export type OpacityEncodingOptions =
       scale?: OpacityScaleOptions;
     };
 
+export interface StrokeWidthScaleOptions {
+  id?: string;
+  type?: "linear" | "log" | "pow" | "sqrt" | "symlog";
+  domain?: "auto" | readonly [number, number];
+  range?: "auto" | readonly [number, number];
+  nice?: boolean;
+  zero?: boolean;
+  clamp?: boolean;
+  reverse?: boolean;
+  base?: number;
+  exponent?: number;
+  constant?: number;
+}
+
+export type StrokeWidthEncodingOptions =
+  | {
+      value: number;
+      field?: never;
+      target?: string;
+      fieldType?: never;
+      scale?: never;
+    }
+  | {
+      field: string;
+      value?: never;
+      target?: string;
+      fieldType?: "quantitative";
+      scale?: StrokeWidthScaleOptions;
+    };
+
 export type RegressionMethod = "linear" | "polynomial" | "loess";
 export type RegressionInterval = "mean" | "prediction";
 
@@ -1376,7 +1967,7 @@ export interface LegendBorderOptions {
 
 export interface LegendOptions {
   target?: string;
-  channels?: readonly ("color" | "strokeDash" | "shape" | "size" | "opacity")[];
+  channels?: readonly ("color" | "strokeDash" | "strokeWidth" | "shape" | "size" | "opacity")[];
   position?: "right" | "left" | "bottom" | "top";
   align?: "left" | "center" | "right";
   direction?: "horizontal" | "vertical";
@@ -1446,6 +2037,17 @@ export interface TitleTextStyleOptions {
   fontWeight?: string | number;
 }
 
+export interface PathOrderEncodingOptions {
+  target?: string;
+  field: string;
+  fieldType?: "quantitative";
+  order?: "ascending" | "descending";
+}
+
+export interface RemovePathOrderOptions {
+  target?: string;
+}
+
 export interface TitleOptions {
   text: string;
   subtitle?: string;
@@ -1488,6 +2090,8 @@ export class ChartProgram {
   createDensityData(options: DensityDataOptions): ChartProgram;
   createRegressionData(options: RegressionDataOptions): ChartProgram;
   createIntervalData(options: IntervalDataOptions): ChartProgram;
+  createWindowData(options: WindowDataOptions): ChartProgram;
+  createBin2DData(options: Bin2DDataOptions): ChartProgram;
 
   createPointMark(options?: {
     id?: string;
@@ -1506,6 +2110,8 @@ export class ChartProgram {
     stroke?: string;
     strokeWidth?: number;
   }): ChartProgram;
+  jitterPoints(options: JitterPointsOptions): ChartProgram;
+  removeJitter(options?: RemoveJitterOptions): ChartProgram;
   createLineMark(options?: {
     id?: string;
     data?: string;
@@ -1571,6 +2177,8 @@ export class ChartProgram {
   createRuleMark(options?: { id?: string; data?: string }): ChartProgram;
   createTextMark(options?: TextMarkOptions): ChartProgram;
   editTextMark(options: EditTextMarkOptions): ChartProgram;
+  layoutLabels(options?: LabelLayoutOptions): ChartProgram;
+  removeLabelLayout(options?: RemoveLabelLayoutOptions): ChartProgram;
   editAreaMark(options: {
     target?: string;
     fill?: string;
@@ -1612,13 +2220,18 @@ export class ChartProgram {
     scale?: ScaleOptions;
   }): ChartProgram;
   encodeGroup(options: { field: string; target?: string; fieldType?: "nominal" }): ChartProgram;
+  encodePathOrder(options: PathOrderEncodingOptions): ChartProgram;
+  encodeParallelCoordinates(options: ParallelCoordinatesEncodingOptions): ChartProgram;
+  removePathOrder(options?: RemovePathOrderOptions): ChartProgram;
   encodeText(options: TextEncodingOptions): ChartProgram;
   encodeHistogram(options: HistogramEncodingOptions): ChartProgram;
   encodeDensity(options: DensityEncodingOptions): ChartProgram;
   editDensity(options: EditDensityOptions): ChartProgram;
+  encodeHorizon(options?: HorizonEncodingOptions): ChartProgram;
+  editHorizon(options: EditHorizonOptions): ChartProgram;
   encodeBarWidth(options?: BarWidthOptions): ChartProgram;
   encodeStroke(options: { target?: string; value: string }): ChartProgram;
-  encodeStrokeWidth(options: { target?: string; value: number }): ChartProgram;
+  encodeStrokeWidth(options: StrokeWidthEncodingOptions): ChartProgram;
 
   createRegression(options?: RegressionOptions): ChartProgram;
   editRegression(options: EditRegressionOptions): ChartProgram;
@@ -1629,6 +2242,15 @@ export class ChartProgram {
   editErrorBandBoundary(options: EditErrorBandBoundaryOptions): ChartProgram;
   createBoxPlot(options?: BoxPlotOptions): ChartProgram;
   editBoxPlot(options: EditBoxPlotOptions): ChartProgram;
+  createGradientPlot(options?: GradientPlotOptions): ChartProgram;
+  editGradientPlot(options: EditGradientPlotOptions): ChartProgram;
+  createViolinPlot(options: ViolinPlotOptions): ChartProgram;
+  createScatterPlot(options: CreateScatterPlotOptions): ChartProgram;
+  createLinePlot(options: CreateLinePlotOptions): ChartProgram;
+  createBarPlot(options: CreateBarPlotOptions): ChartProgram;
+  createHistogram(options: CreateHistogramOptions): ChartProgram;
+  createHeatmap(options: CreateHeatmapOptions): ChartProgram;
+  createParallelCoordinates(options: CreateParallelCoordinatesOptions): ChartProgram;
   removeMark(options?: RemoveMarkOptions): ChartProgram;
   createAxes(options?: CreateAxesOptions): ChartProgram;
   createXAxis(options?: CompleteAxisOptions<XAxisPosition>): ChartProgram;