Published-release documentation · release compatibility

Exact TypeScript Contract

This generated interface is the exact callable contract from types/program.d.ts. Use the family reference pages for defaults, inference, effects, and errors.

Exact TypeScript signatures

This generated block is the exact callable contract from types/program.d.ts. The action entries below provide the readable form, behavior, defaults, and routes.

interface ChartProgramActions {
  createCanvas(options?: CanvasOptions): ChartProgram;
  editCanvas(options: CanvasOptions): ChartProgram;
  fitCanvas(options?: FitCanvasOptions): ChartProgram;
  applyTextMetrics(options: ApplyTextMetricsOptions): ChartProgram;
  removeTextMetrics(): ChartProgram;
  applyTheme(options: ApplyThemeOptions): ChartProgram;
  removeTheme(): ChartProgram;
  createData<Row extends object>(options: CreateDataOptions<Row>): ChartProgram;
  reviseData<Row extends object>(options: ReviseDataOptions<Row>): 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;
  createFlattenData(options: FlattenDataOptions): ChartProgram;
  createLookupData(options: LookupDataOptions): 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;
  createRegressionStatisticsData(options: RegressionStatisticsDataOptions): ChartProgram;
  editRegressionStatisticsData(options?: EditRegressionStatisticsDataOptions): ChartProgram;
  createIntervalData(options: IntervalDataOptions): ChartProgram;
  createECDFData(options: ECDFDataOptions): ChartProgram;
  createTimeUnitData(options: TimeUnitDataOptions): ChartProgram;
  createWindowData(options: WindowDataOptions): ChartProgram;
  createBin2DData(options: Bin2DDataOptions): ChartProgram;
  createSortedData(options: SortedDataOptions): ChartProgram;
  editDerivedData(options: EditDerivedDataOptions): ChartProgram;
  editComputedData(options: EditComputedDataOptions): ChartProgram;
  editFilteredData(options: EditFilteredDataOptions): ChartProgram;
  editFlattenData(options: EditFlattenDataOptions): ChartProgram;
  editLookupData(options: EditLookupDataOptions): 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;
  editSortedData(options: EditSortedDataOptions): 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?: StrokeStyleDetails & { clip?: boolean; id?: string; data?: string; missing?: "error" | "skip"; shape?: PointShape; fill?: string; opacity?: number; stroke?: FilledMarkStroke; strokeWidth?: number; }): ChartProgram;
  editPointMark(options: StrokeStyleDetails & { clip?: boolean; target?: string; missing?: "error" | "skip"; shape?: PointShape; fill?: string; opacity?: number; stroke?: FilledMarkStroke; strokeWidth?: number; }): ChartProgram;
  createTickMark(options?: StrokeStyleDetails & { clip?: boolean; id?: string; data?: string; missing?: "error" | "skip"; length?: number; stroke?: string; strokeWidth?: number; opacity?: number; }): ChartProgram;
  editTickMark(options: StrokeStyleDetails & { clip?: boolean; target?: string; missing?: "error" | "skip"; length?: number; stroke?: string; strokeWidth?: number; opacity?: number; }): ChartProgram;
  jitterPoints(options: JitterPointsOptions): ChartProgram;
  removeJitter(options?: RemoveJitterOptions): ChartProgram;
  packPoints(options: PackPointsOptions): ChartProgram;
  removePointPacking(options?: RemovePointPackingOptions): ChartProgram;
  createLineMark(options?: StrokeStyleDetails & { clip?: boolean; missing?: "error" | "break"; id?: string; data?: string; strokeWidth?: number; curve?: CurveInterpolation; tension?: number; stroke?: string; opacity?: number; closed?: boolean; }): ChartProgram;
  editLineMark(options: StrokeStyleDetails & { clip?: boolean; missing?: "error" | "break"; target?: string; strokeWidth?: number; curve?: CurveInterpolation; tension?: number; stroke?: string; opacity?: number; closed?: boolean; }): ChartProgram;
  createBarMark(options?: RectStyleDetails & { clip?: boolean; id?: string; data?: string; orientation?: "vertical" | "horizontal"; missing?: "error" | "skip"; fill?: FillPaint; opacity?: number; stroke?: FilledMarkStroke; strokeWidth?: number; }): ChartProgram;
  editBarMark(options: RectStyleDetails & { clip?: boolean; target?: string; blend?: "normal" | "difference"; missing?: "error" | "skip"; fill?: FillPaint; opacity?: number; stroke?: FilledMarkStroke; strokeWidth?: number; }): ChartProgram;
  createAreaMark(options?: StrokeStyleDetails & { clip?: boolean; id?: string; data?: string; fill?: FillPaint; opacity?: number; stroke?: string; strokeWidth?: number; curve?: CurveInterpolation; missing?: "error" | "break"; }): ChartProgram;
  createArcMark(options?: StrokeStyleDetails & { id?: string; data?: string; innerRadius?: ArcInnerRadius; padAngle?: number; fill?: string; opacity?: number; stroke?: string; strokeWidth?: number; }): ChartProgram;
  editArcMark(options: StrokeStyleDetails & { target?: string; innerRadius?: ArcInnerRadius; padAngle?: number; fill?: string; opacity?: number; stroke?: string | false; strokeWidth?: number; }): ChartProgram;
  createRectMark(options?: RectMarkOptions): ChartProgram;
  editRectMark(options: EditRectMarkOptions): ChartProgram;
  createRuleMark(options?: { clip?: boolean; id?: string; data?: string; missing?: "error" | "skip" } & RuleStyleOptions): ChartProgram;
  editRuleMark(options: { clip?: boolean; target?: string; missing?: "error" | "skip" } & RuleStyleOptions): ChartProgram;
  createTextMark(options?: TextMarkOptions): ChartProgram;
  createTextPlot(options: CreateTextPlotOptions): ChartProgram;
  createMarkLabels(options?: CreateMarkLabelsOptions): ChartProgram;
  editMarkLabelSelection(options: EditMarkLabelSelectionOptions): ChartProgram;
  editMarkLabelPlacement(options: EditMarkLabelPlacementOptions): ChartProgram;
  removeMarkLabels(options: RemoveMarkLabelsOptions): ChartProgram;
  createAnnotation(options: CreateAnnotationOptions): ChartProgram;
  createStatisticalReference(options: CreateStatisticalReferenceOptions): ChartProgram;
  createReferenceLine(options: CreateReferenceLineOptions): ChartProgram;
  createReferenceBand(options: CreateReferenceBandOptions): ChartProgram;
  editTextMark(options: EditTextMarkOptions): ChartProgram;
  layoutLabels(options?: LabelLayoutOptions): ChartProgram;
  removeLabelLayout(options?: RemoveLabelLayoutOptions): ChartProgram;
  editAreaMark(options: StrokeStyleDetails & { clip?: boolean; target?: string; fill?: FillPaint; opacity?: number; stroke?: string | false; strokeWidth?: number; curve?: CurveInterpolation; missing?: "error" | "break"; }): 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: 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;
  removePointRadius(options?: { target?: string }): ChartProgram;
  encodeXOffset(options: XOffsetEncodingOptions): ChartProgram;
  encodeYOffset(options: YOffsetEncodingOptions): ChartProgram;
  encodeY2(options: SecondaryPositionEncodingOptions): 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;
  removePathOrder(options?: RemovePathOrderOptions): ChartProgram;
  removeCategoryOrder(options: RemoveCategoryOrderOptions): ChartProgram;
  removeEncoding(options: { target?: string; channel: | "x" | "y" | "x2" | "y2" | "xOffset" | "yOffset" | "theta" | "radius" | "color" | "stroke" | "strokeDash" | "strokeWidth" | "size" | "shape" | "angle" | "group" | "opacity" | "text" | "dx" | "dy"; }): ChartProgram;
  encodeText(options: TextEncodingOptions): ChartProgram;
  encodeDx(options: TextOffsetEncodingOptions): ChartProgram;
  encodeDy(options: TextOffsetEncodingOptions): 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: StrokeEncodingOptions): ChartProgram;
  encodeStrokeWidth(options: StrokeWidthEncodingOptions): ChartProgram;
  encodeChannels(options: EncodeChannelsOptions): ChartProgram;
  createRegression(options?: RegressionOptions): ChartProgram;
  editRegression(options: EditRegressionOptions): ChartProgram;
  createErrorBar(options?: ErrorBarOptions): ChartProgram;
  editErrorBar(options: EditErrorBarOptions): ChartProgram;
  createErrorBand(options?: ErrorBandOptions): ChartProgram;
  editErrorBand(options: EditErrorBandOptions): 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;
  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;
  editRadarPlot(options: EditRadarPlotOptions): 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;
  editAxes(options: EditAxesOptions): ChartProgram;
  createXAxis(options?: CompleteAxisOptions<XAxisPosition>): ChartProgram;
  createYAxis(options?: CompleteAxisOptions<YAxisPosition>): 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?: ThetaAxisLabelOptions): ChartProgram;
  editRadialAxisLabels(options?: PolarLabelOptions): ChartProgram;
  editThetaAxisTitle(options?: PolarTitleOptions): ChartProgram;
  editRadialAxisTitle(options?: RadialTitleOptions): ChartProgram;
  createXAxisLine(options?: AxisLineStyleOptions & { target?: string; scale?: string; position?: XAxisPosition }): ChartProgram;
  createYAxisLine(options?: AxisLineStyleOptions & { target?: string; scale?: string; position?: YAxisPosition }): ChartProgram;
  editXAxisLine(options?: AxisLineStyleOptions & { target?: string; position?: XAxisPosition }): ChartProgram;
  editYAxisLine(options?: AxisLineStyleOptions & { target?: string; position?: YAxisPosition }): ChartProgram;
  createXAxisTicks(options?: AxisTickOptions<XAxisPosition>): ChartProgram;
  createYAxisTicks(options?: AxisTickOptions<YAxisPosition>): ChartProgram;
  editXAxisTicks(options?: Omit<AxisTickOptions<XAxisPosition>, "scale">): ChartProgram;
  editYAxisTicks(options?: Omit<AxisTickOptions<YAxisPosition>, "scale">): ChartProgram;
  createXAxisLabels(options?: AxisLabelOptions<XAxisPosition>): ChartProgram;
  createYAxisLabels(options?: AxisLabelOptions<YAxisPosition>): ChartProgram;
  editXAxisLabels(options?: Omit<AxisLabelOptions<XAxisPosition>, "scale">): ChartProgram;
  editYAxisLabels(options?: Omit<AxisLabelOptions<YAxisPosition>, "scale">): ChartProgram;
  createXAxisTicksAndLabels(options?: AxisTicksAndLabelsOptions<XAxisPosition>): ChartProgram;
  createYAxisTicksAndLabels(options?: AxisTicksAndLabelsOptions<YAxisPosition>): ChartProgram;
  editXAxisTicksAndLabels(options: Omit<AxisTicksAndLabelsOptions<XAxisPosition>, "scale">): ChartProgram;
  editYAxisTicksAndLabels(options: Omit<AxisTicksAndLabelsOptions<YAxisPosition>, "scale">): ChartProgram;
  createXAxisTitle(options?: AxisTitleOptions<XAxisPosition>): ChartProgram;
  createYAxisTitle(options?: AxisTitleOptions<YAxisPosition>): ChartProgram;
  editXAxisTitle(options?: Omit<AxisTitleOptions<XAxisPosition>, "scale">): ChartProgram;
  editYAxisTitle(options?: Omit<AxisTitleOptions<YAxisPosition>, "scale">): ChartProgram;
  editXAxis(options: EditAxisOptions<XAxisPosition>): ChartProgram;
  editYAxis(options: EditAxisOptions<YAxisPosition>): ChartProgram;
  editThetaAxis(options: EditThetaAxisOptions): ChartProgram;
  editRadialAxis(options: EditRadialAxisOptions): ChartProgram;
  removeXAxis(options?: RemoveAxisOptions): ChartProgram;
  removeYAxis(options?: RemoveAxisOptions): ChartProgram;
  removeThetaAxis(options?: Omit<RemoveAxisOptions, "target">): ChartProgram;
  removeRadialAxis(options?: Omit<RemoveAxisOptions, "target">): ChartProgram;
  createGrid(options?: CreateGridOptions): ChartProgram;
  createHorizontalGrid(options?: GridDirectionOptions): ChartProgram;
  createVerticalGrid(options?: GridDirectionOptions): ChartProgram;
  createThetaGrid(options?: PolarGridOptions): ChartProgram;
  createRadialGrid(options?: PolarGridOptions): ChartProgram;
  editHorizontalGrid(options: EditGridOptions): ChartProgram;
  editVerticalGrid(options: EditGridOptions): ChartProgram;
  editThetaGrid(options: EditPolarGridOptions): ChartProgram;
  editRadialGrid(options: EditPolarGridOptions): ChartProgram;
  editGrid(options: EditGridDirectionsOptions): ChartProgram;
  removeGrid(options?: RemoveGridOptions): ChartProgram;
  createLegend(options?: LegendOptions): ChartProgram;
  editLegend(options: EditLegendOptions): ChartProgram;
  editLegendBlock(options: EditLegendBlockOptions): ChartProgram;
  editLegendLayout(options: EditLegendLayoutOptions): ChartProgram;
  editLegendLabels(options: EditLegendLabelsOptions): ChartProgram;
  editLegendTitle(options: EditLegendTitleOptions): ChartProgram;
  editLegendSymbols(options: EditLegendSymbolsOptions): ChartProgram;
  editLegendBorder(options: EditLegendBorderOptions): ChartProgram;
  removeLegend(options?: RemoveLegendOptions): ChartProgram;
  createGuides(options?: CreateGuidesOptions): ChartProgram;
  createTitle(options: TitleOptions): ChartProgram;
  editTitle(options: EditTitleOptions): 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: StrokeStyleDetails & { target?: string; color?: string; opacity?: number; stroke?: string | false; strokeWidth?: number; curve?: CurveInterpolation; }): ChartProgram;
  createRegressionLine(options: CreateRegressionLineOptions): ChartProgram;
  editRegressionLine(options: StrokeStyleDetails & { target?: string; strokeWidth?: number; curve?: CurveInterpolation; }): 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;
  editSemantic(options: EditSemanticOptions): ChartProgram;
  createGraphics(options: { id: string; type: GraphicType; length?: number; parent?: string; before?: string; after?: string; }): ChartProgram;
  editGraphics(options: EditGraphicsOptions): ChartProgram;
}

Named option contracts

These declarations are generated from the same source as the action signatures. Follow named nested types to inspect union branches, required combinations, and shared styles. The raw declaration file is also available.

`AggregateOperation`

Expand AggregateOperation

export type AggregateOperation =
  | ScalarAggregateOperation
  | ParameterizedAggregateOperation;
/** HCL modes borrow a chromatic endpoint's hue across an exact RGB-neutral endpoint. */

`AngleEncodingOptions`

Expand AngleEncodingOptions

export type AngleEncodingOptions =
  | { target?: string; value: number; field?: never; fieldType?: never }
  | { target?: string; field: string; fieldType?: "quantitative"; value?: never };

/** Unscaled, signed logical-pixel offsets for independent Text marks. */

`AnnotationAnchor`

Expand AnnotationAnchor

type AnnotationAnchor =
  | {
      anchor: "plot-center";
      x?: never;
      y?: never;
      space?: never;
      source?: never;
      align?: never;
      baseline?: never;
      data?: string;
      coordinate?: string;
    }
  | {
      anchor?: never;
      x?: never;
      y?: never;
      space?: never;
      source?: string;
      data?: never;
      coordinate?: never;
    }
  | {
      anchor?: never;
      x: unknown;
      y: unknown;
      space?: "data";
      source?: string;
      data?: never;
      coordinate?: never;
    }
  | {
      anchor?: never;
      x: number;
      y: number;
      space: "plot";
      source?: never;
      data?: string;
      coordinate?: string;
    };

`AnnotationBaseOptions`

Expand AnnotationBaseOptions

type AnnotationBaseOptions = Omit<TextMarkOptions, "id" | "data" | "source" | "text"> & {
  id?: string;
  text: unknown;
  format?: TextFormat;
  layout?: false | Omit<LabelLayoutOptions, "target">;
};

Related types: TextMarkOptions · TextFormat · LabelLayoutOptions.

`ApplyTextMetricsOptions`

Expand ApplyTextMetricsOptions

export interface ApplyTextMetricsOptions { profile: TextMetricsProfile; }

Related types: TextMetricsProfile.

`ApplyThemeOptions`

Expand ApplyThemeOptions

export interface ApplyThemeOptions {
  theme: ThemeDefinition;
  scope?: "self" | "descendants";
}

Related types: ThemeDefinition.

`ArcInnerRadius`

Expand ArcInnerRadius

export type ArcInnerRadius = number | { unit: "px"; value: number };

`AreaPlotIndependentChannel`

Expand AreaPlotIndependentChannel

export type AreaPlotIndependentChannel = string | ({ field: string } & (
  | { fieldType: "nominal" | "ordinal"; scale?: NonPointCategoricalPositionScaleOptions }
  | { fieldType?: "quantitative"; scale?: NonPointQuantitativePositionScaleOptions }
  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit; scale?: NonPointTemporalPositionScaleOptions }
));

`AreaPlotMeasureChannel`

Expand AreaPlotMeasureChannel

export type AreaPlotMeasureChannel = string | { field: string; scale?: NonPointQuantitativePositionScaleOptions }
  | ({ scale?: NonPointQuantitativePositionScaleOptions } & (
    | { lower: string; upper: string | { datum: number } }
    | { lower: { datum: number }; upper: string }
  ));

`AtLeastOne`

Expand AtLeastOne

type AtLeastOne<T> = {
  [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>
}[keyof T];

`AxisFormat`

Expand AxisFormat

export type AxisFormat =
  | "ticks"
  | ValueFormat
  | { decimals: number };

Related types: ValueFormat.

`AxisLabelLayoutOptions`

Expand AxisLabelLayoutOptions

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";
}

Related types: RotationInput.

`AxisLabelOptions`

Expand AxisLabelOptions

export interface AxisLabelOptions<P extends string>
  extends CartesianAxisLabelStyleOptions, AxisLabelLayoutOptions, DisplayLabelOptions {
  /** Axis resource identity; omission prefers canonical, then a unique named owner. */
  target?: string;
  scale?: string;
  position?: P;
  count?: number;
  rounding?: AxisTickRounding;
  values?: readonly AxisValue[];
}

`AxisLabelStyleOptions`

Expand AxisLabelStyleOptions

export interface AxisLabelStyleOptions {
  offset?: number;
  format?: AxisFormat;
  color?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
}

Related types: AxisFormat.

`AxisLineStyleOptions`

Expand AxisLineStyleOptions

export interface AxisLineStyleOptions {
  color?: string;
  lineWidth?: number;
}

`AxisTickOptions`

Expand AxisTickOptions

export interface AxisTickOptions<P extends string>
  extends CartesianAxisTickStyleOptions {
  /** Axis resource identity; omission prefers canonical, then a unique named owner. */
  target?: string;
  scale?: string;
  position?: P;
  count?: number;
  rounding?: AxisTickRounding;
  values?: readonly AxisValue[];
}
/** Cartesian label maps use typed category values or finite numeric/timestamp keys on continuous scales. Empty mapped labels are omitted without removing ticks. */

`AxisTickRounding`

Expand AxisTickRounding

export type AxisTickRounding = "ceiling" | "nearest";

`AxisTickStyleOptions`

Expand AxisTickStyleOptions

export interface AxisTickStyleOptions extends AxisLineStyleOptions {
  length?: number;
}

Related types: AxisLineStyleOptions.

`AxisTicksAndLabelsOptions`

Expand AxisTicksAndLabelsOptions

export interface AxisTicksAndLabelsOptions<P extends string> {
  /** Axis resource identity; omission prefers canonical, then a unique named owner. */
  target?: string;
  scale?: string;
  position?: P;
  count?: number;
  rounding?: AxisTickRounding;
  values?: readonly AxisValue[];
  ticks?: CartesianAxisTickStyleOptions;
  labels?: CartesianAxisLabelStyleOptions & AxisLabelLayoutOptions & DisplayLabelOptions;
}

`AxisTitleOffset`

Expand AxisTitleOffset

export type AxisTitleOffset = number | Readonly<{ from: "labels"; gap: number }>;

`AxisTitleOptions`

Expand AxisTitleOptions

export interface AxisTitleOptions<P extends string> {
  /** Axis resource identity; omission prefers canonical, then a unique named owner. */
  target?: string;
  /** Signed logical pixels: positive right for x, down for y, independent of scale reversal. */
  alongOffset?: number;
  align?: "left" | "center" | "right";
  /** Defaults to error; allow permits only this title to intersect its own axis labels. */
  overlap?: "error" | "allow";
  baseline?: "top" | "hanging" | "middle" | "alphabetic" | "ideographic" | "bottom";
  /** Hard breaks retain ordered lines with the chosen block baseline, spaced at 1.2 times fontSize. */
  text?: string;
  scale?: string;
  position?: P;
  at?: "start" | "center" | "end" | number;
  /** Signed distance from the axis frame, or a nonnegative gap outside same-owner labels. */
  offset?: AxisTitleOffset;
  rotation?: RotationInput;
  color?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
}

Related types: AxisTitleOffset · RotationInput.

`AxisValue`

Expand AxisValue

export type AxisValue = string | boolean | number;

`BandPositionChannel`

Expand BandPositionChannel

type BandPositionChannel = FacadePositionChannel<
  NonPointZeroSupportingPositionScaleOptions,
  NonPointTemporalPositionScaleOptions,
  NonPointBandPositionScaleOptions
>;
/** With binned quantitative X, aggregate Y per exact interval (and optional series). */

`BandPositionScaleOptions`

Expand BandPositionScaleOptions

export type BandPositionScaleOptions =
  NonPointBandPositionScaleOptions & { unknown?: number };

Related types: NonPointBandPositionScaleOptions.

`BarCategoricalColorChannel`

Expand BarCategoricalColorChannel

type BarCategoricalColorChannel =
  | string
  | {
      field: string;
      fieldType?: "nominal" | "ordinal";
      scale?: NonPointCategoricalColorScaleOptions;
      palette?: Palette;
      layout?: Exclude<ColorLayout, "center">;
    };

`BarColorChannel`

Expand BarColorChannel

type BarColorChannel =
  | BarCategoricalColorChannel
  | QuantitativeBarColorChannel;

`BarFieldPosition`

Expand BarFieldPosition

type BarFieldPosition<T> = T extends string ? T : T & { lower?: never; upper?: never };

`BarRangeOppositePositionChannel`

Expand BarRangeOppositePositionChannel

type BarRangeOppositePositionChannel = string | {
  field: string;
  fieldType?: "nominal" | "ordinal" | "temporal";
  temporalUnit?: TemporalInputUnit;
  scale?: NonPointBandPositionScaleOptions | NonPointTemporalPositionScaleOptions;
  bin?: never;
  aggregate?: never;
  stack?: never;
};

`BarRangePositionChannel`

Expand BarRangePositionChannel

export type BarRangePositionChannel = {
  lower: string;
  upper: string;
  fieldType?: "quantitative";
  scale?: NonPointZeroSupportingPositionScaleOptions;
  field?: never;
  aggregate?: never;
  stack?: never;
};

`BarWidthOptions`

Expand BarWidthOptions

export type BarWidthOptions = { target?: string } & (
  | { band?: number; pixels?: never; interval?: never }
  | { band?: never; pixels: number; interval?: never }
  | { band?: never; pixels?: never; interval: { unit: Exclude<TimeUnit, "week" | "weekday">; insetStart?: number; insetEnd?: number } }
);

Related types: TimeUnit.

`BarYPositionChannel`

Expand BarYPositionChannel

type BarYPositionChannel =
  | string
  | {
      field: string;
      bin?: never;
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      aggregate?: never;
      stack?: never;
      scale?: NonPointTemporalPositionScaleOptions;
    }
  | ({ field: string; bin?: never; stack?: StackMode } & (
      | {
          fieldType?: "quantitative";
          aggregate?: never;
          scale?: NonPointZeroSupportingPositionScaleOptions;
        }
      | {
          fieldType: "nominal" | "ordinal";
          aggregate?: never;
          scale?: NonPointBandPositionScaleOptions;
        }
      | {
          fieldType?: "quantitative" | "nominal" | "ordinal";
          aggregate: AggregateOperation;
          scale?: NonPointZeroSupportingPositionScaleOptions;
        }
    ));

`BaselineDensityPlacement`

Expand BaselineDensityPlacement

export interface BaselineDensityPlacement {
  type: "baseline";
}

`BasicColorChannel`

Expand BasicColorChannel

type BasicColorChannel =
  | string
  | {
      field: string;
      fieldType?: "nominal" | "ordinal";
      scale?: CategoricalColorScaleOptions;
      palette?: Palette;
    }
  | {
      field: string;
      fieldType: "quantitative";
      scale?: ContinuousColorScaleOptions | DiscretizedColorScaleOptions;
      palette?: Palette;
    }
  | {
      field: string;
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      scale?: Omit<ContinuousColorScaleOptions, "midpoint" | "type" | "base" | "exponent" | "constant"> & { midpoint?: "auto"; type?: "sequential" };
      palette?: Palette;
    };

`BasicHistogramEncoding`

Expand BasicHistogramEncoding

type BasicHistogramEncoding =
  HistogramEncodingOptions extends infer T
    ? T extends unknown
      ? Omit<T, "field" | "target" | "coordinate" | "stack"> & {
          stack?: Exclude<StackMode, "center">;
        }
      : never
    : never;

Related types: HistogramEncodingOptions · StackMode.

`BasicShapeChannel`

Expand BasicShapeChannel

export type BasicShapeChannel = string | {
  field: string;
  fieldType?: "nominal";
  scale?: ShapeScaleOptions;
};

Related types: ShapeScaleOptions.

`BasicSizeChannel`

Expand BasicSizeChannel

export type BasicSizeChannel = string | WithoutEncodingTarget<SizeEncodingOptions>;

Related types: WithoutEncodingTarget · SizeEncodingOptions.

`BasicStrokeDashChannel`

Expand BasicStrokeDashChannel

export type BasicStrokeDashChannel =
  StrokeDashEncodingOptions extends infer T
    ? T extends unknown ? Omit<T, "target"> : never
    : never;

Related types: StrokeDashEncodingOptions.

`BeeswarmPackingOptions`

Expand BeeswarmPackingOptions

export interface BeeswarmPackingOptions {
  maxOffset?: PointPackingMaxOffset;
  padding?: number;
  key?: string;
  overflow?: "error" | "overlap";
}

Related types: PointPackingMaxOffset.

`Bin2DCounts`

Expand Bin2DCounts

export interface Bin2DCounts {
  x: number;
  y: number;
}

`Bin2DDataOptions`

Expand Bin2DDataOptions

export interface Bin2DDataOptions {
  id: string;
  source?: string;
  x: string;
  y: string;
  bins?: number | Bin2DCounts;
  extent?: Bin2DExtent;
  assignment?: "edges" | "step";
  includeEmpty?: boolean;
  members?: boolean;
  as?: Bin2DOutputFields;
}

Related types: Bin2DCounts · Bin2DExtent · Bin2DOutputFields.

`Bin2DExtent`

Expand Bin2DExtent

export interface Bin2DExtent {
  x?: readonly [number, number];
  y?: readonly [number, number];
}

`Bin2DOutputFields`

Expand Bin2DOutputFields

export interface Bin2DOutputFields {
  x0?: string;
  x1?: string;
  y0?: string;
  y1?: string;
  count?: string;
  members?: string;
}

`BinDataMode`

Expand BinDataMode

type BinDataMode =
  | { maxBins?: number; step?: never; boundaries?: never }
  | { maxBins?: never; step: number; boundaries?: never }
  | {
      maxBins?: never;
      step?: never;
      boundaries: readonly [number, number, ...number[]];
    };

`BinDataOptions`

Expand BinDataOptions

export type BinDataOptions = {
  id: string;
  source?: string;
  field: string;
  extent?: "auto" | readonly [number, number];
  nice?: boolean;
  zero?: boolean;
  includeEmpty?: boolean;
  members?: boolean;
  weight?: StatisticalWeight;
  missing?: "error" | "drop";
  as?: BinDataOutputFields;
} & BinDataMode;

Related types: StatisticalWeight · BinDataOutputFields · BinDataMode.

`BinDataOutputFields`

Expand BinDataOutputFields

export interface BinDataOutputFields {
  lower?: string;
  upper?: string;
  count?: string;
  members?: string;
}

`BindMarkDataOptions`

Expand BindMarkDataOptions

export interface BindMarkDataOptions {
  target: string;
  data: string;
}

`BinnedHeatmapColorOptions`

Expand BinnedHeatmapColorOptions

export interface BinnedHeatmapColorOptions {
  scale?:
    | NonPointContinuousColorScaleOptions
    | NonPointDiscretizedColorScaleOptions;
  palette?: Palette;
}

`BinnedHeatmapOptions`

Expand BinnedHeatmapOptions

export interface BinnedHeatmapOptions extends HeatmapBaseOptions {
  x: string | BinnedHeatmapPositionChannel;
  y: string | BinnedHeatmapPositionChannel;
  bin: HeatmapBinOptions;
  color?: BinnedHeatmapColorOptions;
}

`BinnedHeatmapPositionChannel`

Expand BinnedHeatmapPositionChannel

export interface BinnedHeatmapPositionChannel {
  field: string;
  fieldType?: "quantitative";
  scale?: NonPointQuantitativePositionScaleOptions;
}

`BootstrapMeanIntervalMethod`

Expand BootstrapMeanIntervalMethod

export interface BootstrapMeanIntervalMethod {
  type: "bootstrap";
  seed: number;
  samples?: number;
}

`BoxPlotCategoryChannel`

Expand BoxPlotCategoryChannel

export interface BoxPlotCategoryChannel {
  field: string;
  fieldType: "nominal" | "ordinal";
  scale?: NonPointBandPositionScaleOptions;
}

Related types: NonPointBandPositionScaleOptions.

`BoxPlotGuideOptions`

Expand BoxPlotGuideOptions

type BoxPlotGuideOptions = Omit<CartesianGuideOptions, "legend"> & { legend?: false };

Related types: CartesianGuideOptions.

`BoxPlotMeasureChannel`

Expand BoxPlotMeasureChannel

export interface BoxPlotMeasureChannel {
  field: string;
  fieldType?: "quantitative";
  scale?: NonPointQuantitativePositionScaleOptions;
}

`BoxPlotOptions`

Expand BoxPlotOptions

export interface BoxPlotOptions {
  summary?: BoxPlotSummaryFields;
  id?: string;
  target?: string;
  data?: string;
  x?: BoxPlotPositionChannel;
  y?: BoxPlotPositionChannel;
  coordinate?: string;
  color?: string | {
    field: string;
    fieldType?: "nominal" | "ordinal";
    scale?: NonPointCategoricalColorScaleOptions;
    palette?: Palette;
  } | { value: string };
  whisker?: BoxPlotWhisker;
  width?: BoxPlotWidth;
  outliers?: boolean;
  box?: RectStyleDetails & {
    fill?: string;
    opacity?: number;
    stroke?: string;
    strokeWidth?: number;
  };
  median?: StrokeStyleDetails & {
    width?: { pixels: number } | "auto";
    stroke?: string;
    strokeWidth?: number;
  };
  outlier?: StrokeStyleDetails & {
    shape?: PointShape;
    radius?: number;
    opacity?: number;
  };
  guides?: false | BoxPlotGuideOptions;
}

`BoxPlotPositionChannel`

Expand BoxPlotPositionChannel

export type BoxPlotPositionChannel =
  | BoxPlotCategoryChannel
  | BoxPlotMeasureChannel;

`BoxPlotSummaryFields`

Expand BoxPlotSummaryFields

export interface BoxPlotSummaryFields {
  min: string;
  q1: string;
  median: string;
  q3: string;
  max: string;
}

`BoxPlotWhisker`

Expand BoxPlotWhisker

export type BoxPlotWhisker = (
  | { type?: "tukey"; factor?: number }
  | { type: "minmax"; factor?: never }
) & Pick<ErrorBarOptions, "caps" | "capSize" | "stroke" | "strokeWidth" | "strokeDash" | "opacity" |
  "lineCap" | "lineJoin" | "miterLimit">;

Related types: ErrorBarOptions.

`BoxPlotWidth`

Expand BoxPlotWidth

type BoxPlotWidth = { band?: number; pixels?: never } | { band?: never; pixels: number };

`CAxes`

Expand CAxes

type CAxes = Omit<CartesianAxesOptions, "x" | "y"> & {
  x?: false | CAxis<XAxisPosition> | readonly [CAxis<XAxisPosition> & { id: string }, ...(CAxis<XAxisPosition> & { id: string })[]];
  y?: false | CAxis<YAxisPosition> | readonly [CAxis<YAxisPosition> & { id: string }, ...(CAxis<YAxisPosition> & { id: string })[]];
};

Related types: CartesianAxesOptions · CAxis · XAxisPosition · YAxisPosition.

`CAxis`

Expand CAxis

type CAxis<P extends string> = Omit<CompleteAxisOptions<P>, "ticksAndLabels"> & {
  ticksAndLabels?: false | Omit<CAxisTicks<P>, "scale" | "position" | "target">;
};

Related types: CompleteAxisOptions · CAxisTicks.

`CAxisTicks`

Expand CAxisTicks

type CAxisTicks<P extends string> = Omit<AxisTicksAndLabelsOptions<P>, "labels"> & {
  labels?: CartesianAxisLabelStyleOptions & AxisLabelLayoutOptions & DisplayLabelOptions;
};

`CCategoricalGuides`

Expand CCategoricalGuides

type CCategoricalGuides = Omit<CartesianCategoricalGuideOptions, "axes"> & {
  axes?: false | CAxes;
};

Related types: CartesianCategoricalGuideOptions · CAxes.

`CPathGuides`

Expand CPathGuides

type CPathGuides = Omit<CartesianPathGuideOptions, "axes"> & {
  axes?: false | CAxes;
};

Related types: CartesianPathGuideOptions · CAxes.

`CanvasOptions`

Expand CanvasOptions

export interface CanvasOptions {
  width?: number;
  height?: number;
  background?: string;
  margin?: number | Partial<Record<"top" | "right" | "bottom" | "left", number>>;
  /** Exact inner dimensions with automatic outer guide margins; false disables this mode. */
  plot?: { width: number; height: number } | false;
  /** Optional inner plot outline. Defaults off; an object replaces the complete style on edit. */
  plotBorder?: false | {
    /** Non-empty color string. Defaults to #ddd. */
    color?: string;
    /** Positive finite width smaller than both plot dimensions. Defaults to 1. */
    lineWidth?: number;
    /** Paint this border before ordinary marks. Defaults to false. */
    underlay?: boolean;
  };
}

`CartesianAxesOptions`

Expand CartesianAxesOptions

type CartesianAxesOptions = Omit<
  CreateAxesOptions,
  "coordinate" | "theta" | "radius"
> & {
  coordinate?: { id?: string; type?: "auto" | "cartesian" };
};

Related types: CreateAxesOptions.

`CartesianAxisLabelColorMap`

Expand CartesianAxisLabelColorMap

export type CartesianAxisLabelColorMap = ReadonlyArray<Readonly<{
  value: DatasetScalar;
  color: string;
}>>;

Related types: DatasetScalar.

`CartesianAxisLabelStyleOptions`

Expand CartesianAxisLabelStyleOptions

export interface CartesianAxisLabelStyleOptions extends AxisLabelStyleOptions {
  /** Local text alignment before rotation; omitted edits retain existing intent. */
  align?: "left" | "center" | "right";
  /** Typed raw-tick color overrides; missing entries use color. Auto removes the map. */
  colorMap?: CartesianAxisLabelColorMap | "auto";
  /** Keep unrotated label bounds inside the mapped axis span; defaults to false. */
  flush?: boolean;
  /** Only flush mapped ticks within this non-negative distance of a range edge. Auto restores all-label containment. */
  flushThreshold?: number | "auto";
  /** Signed displacement from the mapped tick position, independent of outward offset. */
  alongOffset?: number;
}

`CartesianAxisTickStyleOptions`

Expand CartesianAxisTickStyleOptions

export interface CartesianAxisTickStyleOptions extends AxisTickStyleOptions {
  strokeDash?: readonly number[];
  /** Typed raw-value overrides. Empty arrays and auto clear only the map. */
  strokeDashMap?: CartesianGuideDashMap | "auto";
  /** Signed logical pixels along the axis: positive right for x, down for y. */
  alongOffset?: number;
}

Related types: AxisTickStyleOptions · CartesianGuideDashMap.

`CartesianCategoricalGuideOptions`

Expand CartesianCategoricalGuideOptions

type CartesianCategoricalGuideOptions = Omit<CartesianGuideOptions, "legend"> & {
  legend?: false | (Omit<
    SeparateFilledLegendOptions,
    "count" | "values" | "gradient" | "labels" | "order" | "representation" | "symbol" | "titlePosition"
  > & {
    titlePosition?: "top" | "left";
    symbol?: FilledLegendSymbolRecipe;
    labels?: CategoricalLegendTextOptions;
    order?: CartesianLegendOrder;
  });
};

`CartesianCategoricalPointGuideOptions`

Expand CartesianCategoricalPointGuideOptions

type CartesianCategoricalPointGuideOptions = Omit<CartesianGuideOptions, "legend"> & {
  legend?: false | (Omit<CategoricalPointLegendOptions, "count" | "values" | "gradient" | "labels" | "order" | "symbol" | "titlePosition"> & {
    titlePosition?: "top" | "left";
    symbol?: FilledLegendSymbolRecipe; labels?: CategoricalLegendTextOptions; order?: CartesianLegendOrder;
  });
};

`CartesianGridOptions`

Expand CartesianGridOptions

type CartesianGridOptions = Pick<CreateGridOptions, "horizontal" | "vertical">;

Related types: CreateGridOptions.

`CartesianGuideDashMap`

Expand CartesianGuideDashMap

export type CartesianGuideDashMap = ReadonlyArray<Readonly<{
  value: AxisValue;
  strokeDash: readonly number[];
}>>;

Related types: AxisValue.

`CartesianGuideOptions`

Expand CartesianGuideOptions

type CartesianGuideOptions = {
  axes?: false | CartesianAxesOptions;
  grid?: false | CartesianGridOptions;
  legend?: false | (DistributiveLegendOmit<FilledMarkLegendOptions, "order"> & { order?: CartesianLegendOrder });
};

`CartesianLegendOrder`

Expand CartesianLegendOrder

type CartesianLegendOrder = LegendValueOrder | { channel: "x" | "y"; values?: never };

Related types: LegendValueOrder.

`CartesianPathGuideOptions`

Expand CartesianPathGuideOptions

type CartesianPathGuideOptions = Omit<CartesianGuideOptions, "legend"> & {
  legend?: false | (Omit<PathLegendOptions, "order"> & { order?: LegendValueOrder });
};

`CartesianSeparateGuideOptions`

Expand CartesianSeparateGuideOptions

type CartesianSeparateGuideOptions = Omit<CartesianGuideOptions, "legend"> & {
  legend?: false | (DistributiveLegendOmit<SeparateFilledLegendOptions, "order"> & { order?: CartesianLegendOrder });
};

`CategoricalColorScaleOptions`

Expand CategoricalColorScaleOptions

export type CategoricalColorScaleOptions =
  NonPointCategoricalColorScaleOptions & { unknown?: string };

`CategoricalEncodingOptions`

Expand CategoricalEncodingOptions

export interface CategoricalEncodingOptions {
  field: string;
  target?: string;
  fieldType?: "nominal" | "ordinal";
  scale?: CategoricalColorScaleOptions;
  palette?: Palette;
  /** Aggregate bars default to overlay for their category field, otherwise group;
   * existing groups and stored or explicit layouts take precedence. */
  layout?: ColorLayout;
}

Related types: CategoricalColorScaleOptions · Palette · ColorLayout.

`CategoricalLegendTextOptions`

Expand CategoricalLegendTextOptions

type CategoricalLegendTextOptions = {
  offset?: number;
  color?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
  format?: "auto";
};

`CategoricalPointLegendOptions`

Expand CategoricalPointLegendOptions

type CategoricalPointLegendOptions = DistributiveLegendOmit<Exclude<FilledMarkLegendOptions, { combine: "color-size" }>, "representation">;

`CategoricalPolarAxesOptions`

Expand CategoricalPolarAxesOptions

type CategoricalPolarAxesOptions = Omit<
  Pick<CreateAxesOptions, "theta" | "radius">,
  "theta"
> & {
  coordinate?: { id?: string; type?: "auto" | "polar" };
  theta?: false | CategoricalThetaAxisOptions;
};

`CategoricalPolarGridOptions`

Expand CategoricalPolarGridOptions

type CategoricalPolarGridOptions = Omit<
  Pick<CreateGridOptions, "theta" | "radial">,
  "theta"
> & {
  theta?: boolean | CategoricalThetaGridOptions;
};

`CategoricalPositionScaleOptions`

Expand CategoricalPositionScaleOptions

export type CategoricalPositionScaleOptions =
  | BandPositionScaleOptions
  | PointPositionScaleOptions;

`CategoricalSizeScaleOptions`

Expand CategoricalSizeScaleOptions

export type CategoricalSizeScaleOptions = SizeScaleCommonOptions & {
  type?: "ordinal";
  domain?: "auto" | readonly (string | number | boolean)[];
  range?: "auto" | readonly [number, ...number[]];
  clamp?: never;
  base?: never;
  exponent?: never;
};

Related types: SizeScaleCommonOptions.

`CategoricalThetaAxisOptions`

Expand CategoricalThetaAxisOptions

type CategoricalThetaAxisOptions = Omit<CompletePolarAxisOptions, "ticksAndLabels"> & {
  ticksAndLabels?: false | CategoricalThetaTicksAndLabelsOptions;
};

`CategoricalThetaGridOptions`

Expand CategoricalThetaGridOptions

type CategoricalThetaGridOptions = Omit<PolarGridOptions, "count"> & {
  count?: never;
};

Related types: PolarGridOptions.

`CategoricalThetaTicksAndLabelsOptions`

Expand CategoricalThetaTicksAndLabelsOptions

type CategoricalThetaTicksAndLabelsOptions = Omit<
  PolarTicksAndLabelsOptions,
  "count" | "labels"
> & {
  count?: never;
  labels?: Omit<AxisLabelStyleOptions, "format"> & DisplayLabelOptions &
    { format?: "auto" };
};

`CategoryDensityPlacement`

Expand CategoryDensityPlacement

export interface CategoryDensityPlacement {
  type: "category";
  side?: DensityPlacementSide;
  width?: DensityPlacementWidth;
  split?: DensityPlacementSplit;
  scale?: NonPointBandPositionScaleOptions;
}

`CategoryOrder`

Expand CategoryOrder

export type CategoryOrder =
  | {
      values: readonly CategoryValue[];
      by?: never;
      direction?: never;
    }
  | {
      values?: never;
      by: "category" | "count" | CategoryOrderSummary;
      direction?: "ascending" | "descending";
    };

Related types: CategoryValue · CategoryOrderSummary.

`CategoryOrderSummary`

Expand CategoryOrderSummary

export type CategoryOrderSummary = {
  field: string;
  aggregate: "sum" | "mean" | "min" | "max";
};

`CategoryValue`

Expand CategoryValue

export type CategoryValue = string | number | boolean;

`ColorEncodingOptions`

Expand ColorEncodingOptions

export type ColorEncodingOptions =
  | { value: string; target?: string; field?: never; fieldType?: never;
      scale?: never; palette?: never; layout?: never; aggregate?: never; temporalUnit?: never }
  | (CategoricalEncodingOptions & { value?: never })
  | {
      field: string;
      target?: string;
      value?: never;
      fieldType: "quantitative";
      aggregate?: AggregateOperation;
      scale?: ContinuousColorScaleOptions | DiscretizedColorScaleOptions;
      palette?: Palette;
      layout?: never;
    }
  | {
      field: string;
      target?: string;
      value?: never;
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      aggregate?: never;
      scale?: Omit<ContinuousColorScaleOptions, "midpoint" | "type" | "base" | "exponent" | "constant"> & { midpoint?: "auto"; type?: "sequential" };
      palette?: Palette;
      layout?: never;
    };

`ColorGuides`

Expand ColorGuides

type ColorGuides = Omit<CartesianGuideOptions, "legend"> & {
  legend?: false | (DistributiveLegendOmit<SeparateFilledLegendOptions, "order"> & {
    order?: CartesianLegendOrder;
  });
};

`ColorLayout`

Expand ColorLayout

export type ColorLayout =
  | "stack"
  | "fill"
  | "group"
  | "overlay"
  | "diverging"
  | "center";

`CompleteAxisOptions`

Expand CompleteAxisOptions

export interface CompleteAxisOptions<P extends string> {
  /** Paint the complete Cartesian axis before ordinary marks. Defaults to false. */
  underlay?: boolean;
  /** Omission retains the canonical x/y identity. */
  id?: string;
  /** Non-negative outward displacement of the complete axis frame in logical pixels. */
  offset?: number;
  scale?: string;
  coordinate?: string;
  position?: P;
  line?: false | AxisLineStyleOptions;
  ticksAndLabels?: false | Omit<AxisTicksAndLabelsOptions<P>, "scale" | "position" | "target">;
  title?: false | Omit<AxisTitleOptions<P>, "scale" | "position" | "target">;
}

`CompleteDataBaseOptions`

Expand CompleteDataBaseOptions

type CompleteDataBaseOptions = {
  id: string;
  source?: string;
  key: string;
  groupBy?: string | readonly string[];
  fill?: Readonly<Record<string, DatasetScalar>>;
  members?: string;
};

Related types: DatasetScalar.

`CompleteDataOptions`

Expand CompleteDataOptions

export type CompleteDataOptions = CompleteDataBaseOptions & (
  | { values: readonly [DatasetScalar, ...DatasetScalar[]]; sequence?: never }
  | {
      values?: never;
      sequence: { start: number; end: number; step: number };
    }
  | { values?: never; sequence?: never }
);

Related types: CompleteDataBaseOptions · DatasetScalar.

`CompletePolarAxisOptions`

Expand CompletePolarAxisOptions

export interface CompletePolarAxisOptions extends Omit<PolarGuideResourceOptions, "angle"> {
  line?: false | AxisLineStyleOptions;
  ticksAndLabels?: false | PolarTicksAndLabelsOptions;
  title?: false | PolarTitleOptions;
}

`CompleteRadialAxisOptions`

Expand CompleteRadialAxisOptions

export interface CompleteRadialAxisOptions
  extends Omit<CompletePolarAxisOptions, "title"> {
  angle?: number;
  title?: false | RadialTitleOptions;
}

Related types: CompletePolarAxisOptions · RadialTitleOptions.

`CompleteThetaAxisOptions`

Expand CompleteThetaAxisOptions

export interface CompleteThetaAxisOptions
  extends Omit<CompletePolarAxisOptions, "ticksAndLabels"> {
  ticksAndLabels?: false | ThetaTicksAndLabelsOptions;
}

`CompositionAlign`

Expand CompositionAlign

export type CompositionAlign = "start" | "center" | "end";

`CompositionPadding`

Expand CompositionPadding

export interface CompositionPadding {
  top?: number;
  right?: number;
  bottom?: number;
  left?: number;
}

`ComputedDataOptions`

Expand ComputedDataOptions

export interface ComputedDataOptions {
  id: string;
  source?: string;
  as: string;
  expression: ComputedExpression;
}

Related types: ComputedExpression.

`ComputedExpression`

Expand ComputedExpression

export type ComputedExpression =
  | { readonly field: string }
  | { readonly constant: number | string | boolean | null }
  | {
      readonly op: "getPath";
      readonly operand: { readonly field: string };
      readonly path: readonly [string, ...string[]];
    }
  | {
      readonly op: "replaceLiteral";
      readonly operand: ComputedExpression;
      readonly search: string;
      readonly replacement: string;
    }
  | {
      readonly op: "datePart";
      readonly part: "year";
      readonly operand: ComputedExpression;
      readonly timeZone?: string;
    }
  | {
      readonly op: "parseTime";
      readonly operand: ComputedExpression;
      readonly format?: ParseTimeFormat;
    }
  | {
      readonly op: "negate" | "absolute" | "log" | "sqrt" | "floor" | "not" | "isNull" | "toNumber";
      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;
    };

Related types: ParseTimeFormat.

`ConfidenceIntervalMethod`

Expand ConfidenceIntervalMethod

export type ConfidenceIntervalMethod = "normal" | "student-t";
/** Seeded percentile bootstrap of nonweighted means; samples defaults to 1000. */

`ContinuousCartesianGridOptions`

Expand ContinuousCartesianGridOptions

type ContinuousCartesianGridOptions = {
  vertical?: boolean | ContinuousGridDirectionOptions;
  horizontal?: boolean | ContinuousGridDirectionOptions;
};

Related types: ContinuousGridDirectionOptions.

`ContinuousColorInterpolation`

Expand ContinuousColorInterpolation

export type ContinuousColorInterpolation =
  | "rgb"
  | "hsl"
  | "hsl-long"
  | "lab"
  | "hcl"
  | "hcl-long"
  | "cubehelix"
  | "cubehelix-long";
/** A simple polygon around its unchanged input origin; defaults to equal-area normalization. */

`ContinuousColorScaleOptions`

Expand ContinuousColorScaleOptions

export type ContinuousColorScaleOptions =
  NonPointContinuousColorScaleOptions & { unknown?: string };

Related types: NonPointContinuousColorScaleOptions.

`ContinuousGridDirectionOptions`

Expand ContinuousGridDirectionOptions

type ContinuousGridDirectionOptions = Omit<GridDirectionOptions, "bandPosition"> & {
  /** Continuous position scales do not have categorical band edges. */
  bandPosition?: never;
};

Related types: GridDirectionOptions.

`ContinuousSizeScaleOptions`

Expand ContinuousSizeScaleOptions

type ContinuousSizeScaleOptions = SizeScaleCommonOptions &
  ScaleFields<"clamp"> & {
    domain?: "auto" | readonly [number, number];
    range?: "auto" | readonly [number, number];
  };

Related types: SizeScaleCommonOptions · ScaleFields.

`CoordinateAspect`

Expand CoordinateAspect

export type CoordinateAspect = "auto" | {
  mode: "frame" | "data";
  ratio: number;
  alignX?: CoordinateAspectAlign;
  alignY?: CoordinateAspectAlign;
};

Related types: CoordinateAspectAlign.

`CoordinateAspectAlign`

Expand CoordinateAspectAlign

export type CoordinateAspectAlign = "start" | "center" | "end";

`CreateAnnotationOptions`

Expand CreateAnnotationOptions

export type CreateAnnotationOptions = AnnotationBaseOptions & AnnotationAnchor;

Related types: AnnotationBaseOptions · AnnotationAnchor.

`CreateAreaPlotOptions`

Expand CreateAreaPlotOptions

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 & { clip?: boolean; fill?: FillPaint; opacity?: number; stroke?: string; strokeWidth?: number; curve?: CurveInterpolation };
  guides?: false | (Omit<DensityPlotGuideOptions, "grid"> & { grid?: false | CartesianGridOptions });
} & (
  | { 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 }
);

`CreateAxesOptions`

Expand CreateAxesOptions

export interface CreateAxesOptions {
  coordinate?: {
    id?: string;
    type?: "auto" | "cartesian" | "polar" | "parallel";
  };
  x?: false | CompleteAxisOptions<XAxisPosition> | readonly [NamedCompleteAxis<XAxisPosition>, ...NamedCompleteAxis<XAxisPosition>[]];
  y?: false | CompleteAxisOptions<YAxisPosition> | readonly [NamedCompleteAxis<YAxisPosition>, ...NamedCompleteAxis<YAxisPosition>[]];
  theta?: false | CompletePolarAxisOptions;
  radius?: false | CompleteRadialAxisOptions;
}

`CreateBarPlotOptions`

Expand CreateBarPlotOptions

export type CreateBarPlotOptions = {
  /** Forward the native mark missing-value policy. */
  missing?: "error" | "skip";
  id?: string;
  data?: string;
  coordinate?: string;
  orientation?: "vertical" | "horizontal";
  color?: BarColorChannel;
  width?: Omit<BarWidthOptions, "target" | "interval">;
  bar?: RectStyleDetails & {
    clip?: boolean;
    fill?: FillPaint;
    opacity?: number;
    stroke?: FilledMarkStroke;
    strokeWidth?: number;
  };
  guides?: false | ColorGuides;
} & (
  | { x: BarFieldPosition<BandPositionChannel>; y: BarFieldPosition<BarYPositionChannel> }
  | { x: BarRangePositionChannel; y: BarRangeOppositePositionChannel }
  | { x: BarRangeOppositePositionChannel; y: BarRangePositionChannel }
);

`CreateBeeswarmPlotOptions`

Expand CreateBeeswarmPlotOptions

export type CreateBeeswarmPlotOptions = {
  id?: string;
  data?: string;
  coordinate?: string;
  color?: BasicColorChannel;
  size?: BasicSizeChannel;
  shape?: BasicShapeChannel;
  point?: StrokeStyleDetails & {
    clip?: boolean;
    radius?: number;
    shape?: PointShape;
    fill?: string;
    opacity?: number;
    stroke?: FilledMarkStroke;
    strokeWidth?: number;
  };
  packing?: false | BeeswarmPackingOptions;
  guides?: false | CartesianGuideOptions;
} & (
  | { x: RugMeasureChannel; y: StripCategoryChannel }
  | { x: StripCategoryChannel; y: RugMeasureChannel }
);

`CreateCoordinateOptions`

Expand CreateCoordinateOptions

export interface CreateCoordinateOptions {
  id?: string;
  type?: "cartesian" | "polar" | "parallel";
  layers?: readonly string[];
}

`CreateDataOptions`

Expand CreateDataOptions

export interface CreateDataOptions<Row extends object> {
  id?: string;
  values: readonly (Row extends readonly unknown[] ? never : Row & StoredCell<Row>)[];
  schema?: SourceSchemaInput;
}

Related types: StoredCell · SourceSchemaInput.

`CreateDensityPlotOptions`

Expand CreateDensityPlotOptions

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 & { clip?: boolean; fill?: FillPaint; opacity?: number; stroke?: string; strokeWidth?: number; curve?: CurveInterpolation };
  guides?: false | DensityPlotGuideOptions;
}

`CreateDerivedDataOptions`

Expand CreateDerivedDataOptions

export interface CreateDerivedDataOptions {
  id: string;
  source: string;
  transform: readonly [DatasetTransform];
}

Related types: DatasetTransform.

`CreateDotPlotOptions`

Expand CreateDotPlotOptions

export interface CreateDotPlotOptions extends EndpointPlotBaseOptions {
  value: EndpointValueChannel;
  point?: CreateScatterPlotOptions["point"];
  labels?: false | EndpointLabelOptions;
}

`CreateDumbbellPlotOptions`

Expand CreateDumbbellPlotOptions

export interface CreateDumbbellPlotOptions extends EndpointPlotBaseOptions {
  start: EndpointValueChannel;
  end: EndpointValueChannel;
  startPoint?: CreateScatterPlotOptions["point"];
  endPoint?: CreateScatterPlotOptions["point"];
  connector?: RuleStyleOptions & { clip?: boolean };
  labels?: false | (EndpointLabelOptions & { endpoint?: "start" | "end" | "both" });
}

`CreateECDFPlotOptions`

Expand CreateECDFPlotOptions

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 & { clip?: boolean; strokeWidth?: number; stroke?: string; opacity?: number };
  labels?: false | EndpointLabelOptions;
  guides?: false | CartesianPathGuideOptions;
}

`CreateGridOptions`

Expand CreateGridOptions

export interface CreateGridOptions {
  horizontal?: boolean | GridDirectionOptions;
  vertical?: boolean | GridDirectionOptions;
  theta?: boolean | PolarGridOptions;
  radial?: boolean | PolarGridOptions;
}

Related types: GridDirectionOptions · PolarGridOptions.

`CreateGuidesOptions`

Expand CreateGuidesOptions

export interface CreateGuidesOptions {
  axes?: false | CreateAxesOptions;
  grid?: false | CreateGridOptions;
  legend?: false | LegendOptions;
}

Related types: CreateAxesOptions · CreateGridOptions · LegendOptions.

`CreateHeatmapOptions`

Expand CreateHeatmapOptions

export type CreateHeatmapOptions =
  | PreGriddedHeatmapOptions
  | BinnedHeatmapOptions;

`CreateHistogramOptions`

Expand CreateHistogramOptions

export type CreateHistogramOptions = BasicHistogramEncoding & {
  id?: string;
  data?: string;
  coordinate?: string;
  field: string;
  color?: HistogramCategoricalColorChannel;
  bar?: RectStyleDetails & {
    clip?: boolean;
    fill?: FillPaint;
    opacity?: number;
    stroke?: FilledMarkStroke;
    strokeWidth?: number;
  };
  guides?: false | (Omit<CartesianCategoricalGuideOptions, "grid"> & {
    /** Bin position and count axes are continuous; neither grid has categorical band edges. */
    grid?: false | ContinuousCartesianGridOptions;
  });
};

`CreateHorizonPlotOptions`

Expand CreateHorizonPlotOptions

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 & { clip?: boolean; opacity?: number; stroke?: string; strokeWidth?: number; curve?: CurveInterpolation };
  guides?: false | HorizonPlotGuideOptions;
}

`CreateIntervalPlotOptions`

Expand CreateIntervalPlotOptions

export type CreateIntervalPlotOptions = IntervalPlotBaseOptions & (
  | {
      x: string | ErrorBarPositionChannel;
      y: string | ErrorBarIntervalChannel;
    }
  | {
      x: string | ErrorBarIntervalChannel;
      y: string | ErrorBarPositionChannel;
    }
);

`CreateLinePlotOptions`

Expand CreateLinePlotOptions

export interface CreateLinePlotOptions {
  id?: string;
  data?: string;
  coordinate?: string;
  x: LineXPositionChannel;
  y: LineYPositionChannel;
  color?: LineCategoricalColorChannel<CategoricalColorScaleOptions>;
  groupBy?: string | readonly [string, ...string[]];
  strokeDash?: BasicStrokeDashChannel;
  line?: StrokeStyleDetails & {
    clip?: boolean;
    missing?: "error" | "break";
    strokeWidth?: number;
    curve?: CurveInterpolation;
    tension?: number;
    stroke?: string;
    opacity?: number;
    closed?: false;
  };
  guides?: false | (Omit<CPathGuides, "legend" | "grid"> & {
    grid?: false | (Omit<CartesianGridOptions, "horizontal"> & {
      horizontal?: boolean | (Omit<GridDirectionOptions, "bandPosition"> & {
        /** Line y is continuous; band positioning is available only for categorical x grids. */
        bandPosition?: never;
      });
    });
    legend?: false | (Omit<PathLegendOptions, "order"> & {
      order?: LegendValueOrder | { channel: "x"; values?: never };
    });
  });
}

`CreateLollipopPlotOptions`

Expand CreateLollipopPlotOptions

export interface CreateLollipopPlotOptions extends EndpointPlotBaseOptions {
  value: EndpointValueChannel;
  baseline?: number;
  point?: CreateScatterPlotOptions["point"];
  stem?: RuleStyleOptions & { clip?: boolean };
  labels?: false | EndpointLabelOptions;
}

`CreateMarkLabelsOptions`

Expand CreateMarkLabelsOptions

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. */

`CreateParallelAxisOptions`

Expand CreateParallelAxisOptions

export type CreateParallelAxisOptions = ParallelAxisComponentsOptions;

Related types: ParallelAxisComponentsOptions.

`CreateParallelCoordinatesOptions`

Expand CreateParallelCoordinatesOptions

export interface CreateParallelCoordinatesOptions {
  id?: string;
  data?: string;
  coordinate?: string;
  dimensions: readonly [ParallelDimension, ParallelDimension, ...ParallelDimension[]];
  key?: string;
  missing?: ParallelMissingPolicy;
  color?: LineCategoricalColorChannel;
  strokeDash?: NonCartesianStrokeDashChannel;
  line?: StrokeStyleDetails & {
    strokeWidth?: number;
    stroke?: string;
    opacity?: number;
    curve?: "linear";
    closed?: false;
  };
  guides?: false | ParallelGuideOptions;
}

`CreatePiePlotOptions`

Expand CreatePiePlotOptions

export type CreatePiePlotOptions = {
  id?: string;
  data?: string;
  coordinate?: string;
  category: PieCategory;
  color?: false | PieColor;
  radius?: PieRadiusChannel;
  arc?: StrokeStyleDetails & { innerRadius?: ArcInnerRadius; 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" });

`CreatePolarLinePlotOptions`

Expand CreatePolarLinePlotOptions

export interface CreatePolarLinePlotOptions {
  id?: string;
  data?: string;
  coordinate?: string;
  theta: PolarThetaChannel;
  radius: PolarRadiusChannel;
  color?: LineCategoricalColorChannel;
  groupBy?: string | readonly [string, ...string[]];
  strokeDash?: NonCartesianStrokeDashChannel;
  line?: Omit<NonNullable<CreateLinePlotOptions["line"]>, "clip" | "missing" | "closed" | "curve" | "tension"> & {
    curve?: "linear";
    closed?: boolean;
  };
  guides?: false | PolarPathGuideOptions;
}

`CreatePolarScatterPlotOptions`

Expand CreatePolarScatterPlotOptions

export interface CreatePolarScatterPlotOptions {
  id?: string;
  data?: string;
  coordinate?: string;
  theta: PolarThetaChannel;
  radius: PolarRadiusChannel;
  color?: BasicColorChannel;
  size?: BasicSizeChannel;
  shape?: BasicShapeChannel;
  point?: Omit<NonNullable<CreateScatterPlotOptions["point"]>, "clip">;
  guides?: false | PolarPointGuideOptions;
}

`CreateRadarPlotOptions`

Expand CreateRadarPlotOptions

export type CreateRadarPlotOptions = {
  id?: string;
  data?: string;
  coordinate?: string;
  groupBy?: string | readonly [string, ...string[]];
  order?: readonly [
    RadarCategoryValue,
    RadarCategoryValue,
    RadarCategoryValue,
    ...RadarCategoryValue[]
  ];
  color?: LineCategoricalColorChannel;
  strokeDash?: NonCartesianStrokeDashChannel;
  line?: Omit<NonNullable<CreateLinePlotOptions["line"]>, "clip" | "missing" | "closed" | "curve" | "tension"> & {
    curve?: "linear";
    closed?: true;
  };
  guides?: false | RadarGuideOptions;
} & (
  | { category: RadarCategoryChannel; value: PolarRadiusChannel; wide?: never }
  | { wide: RadarWideOptions; category?: never; value?: never }
);

`CreateRadialAxisLabelsOptions`

Expand CreateRadialAxisLabelsOptions

export type CreateRadialAxisLabelsOptions = Omit<PolarLabelOptions, "count" | "values"> &
  PolarAxisTickSelection & PolarGuideResourceOptions;

`CreateRadialAxisLineOptions`

Expand CreateRadialAxisLineOptions

export type CreateRadialAxisLineOptions = AxisLineStyleOptions & PolarGuideResourceOptions;

`CreateRadialAxisTicksOptions`

Expand CreateRadialAxisTicksOptions

export type CreateRadialAxisTicksOptions = Omit<PolarTickOptions, "count" | "values"> &
  PolarAxisTickSelection & PolarGuideResourceOptions;

`CreateRadialAxisTitleOptions`

Expand CreateRadialAxisTitleOptions

export type CreateRadialAxisTitleOptions = RadialTitleOptions & PolarGuideResourceOptions;

`CreateRadialBarPlotOptions`

Expand CreateRadialBarPlotOptions

export type CreateRadialBarPlotOptions = CreateRosePlotOptions;

Related types: CreateRosePlotOptions.

`CreateRaincloudPlotOptions`

Expand CreateRaincloudPlotOptions

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?: false | RaincloudColorChannel;
  guides?: false | CartesianCategoricalPointGuideOptions;
}

`CreateReferenceBandOptions`

Expand CreateReferenceBandOptions

export type CreateReferenceBandOptions =
  | (Omit<RectMarkOptions, "clip" | "data"> &
      ReferenceBinding<readonly [unknown, unknown], readonly [number, number]>)
  | (DynamicReferenceBinding & Omit<RectMarkOptions, "clip" | "id" | "data" | "source"> & {
      readonly statistics: readonly [ReferenceStatistic, ReferenceStatistic];
    });

/** Constant or quantitative stroke width on Line, Rule, or row-owned Rect marks. */

`CreateReferenceLineOptions`

Expand CreateReferenceLineOptions

export type CreateReferenceLineOptions =
  | ({ id?: string } & RuleStyleOptions & ReferenceBinding<unknown, number>)
  | (DynamicReferenceBinding & RuleStyleOptions & {
      readonly statistic: ReferenceStatistic;
    });

`CreateRegressionBandOptions`

Expand CreateRegressionBandOptions

export interface CreateRegressionBandOptions extends StrokeStyleDetails {
  id: string;
  data: string;
  x: string;
  lower: string;
  upper: string;
  groupBy?: string;
  coordinate: string;
  xScale: string;
  yScale: string;
  color?: string;
  opacity?: number;
  stroke?: string;
  strokeWidth?: number;
  curve?: CurveInterpolation;
}

Related types: StrokeStyleDetails · CurveInterpolation.

`CreateRegressionLineOptions`

Expand CreateRegressionLineOptions

export interface CreateRegressionLineOptions extends StrokeStyleDetails {
  id: string;
  data: string;
  x: string;
  y: string;
  groupBy?: string;
  coordinate: string;
  xScale: string;
  yScale: string;
  colorScale?: string;
  strokeWidth?: number;
  curve?: CurveInterpolation;
}

Related types: StrokeStyleDetails · CurveInterpolation.

`CreateRegressionPlotOptions`

Expand CreateRegressionPlotOptions

export type CreateRegressionPlotOptions = RegressionPlotBaseOptions &
  RegressionPlotStatisticalOptions<RegressionOptions>;

`CreateRosePlotOptions`

Expand CreateRosePlotOptions

export type CreateRosePlotOptions = Omit<CreatePiePlotOptions, "guides" | "arc" | "aggregate" | "value" | "radius"> & {
  radiusScale?: MeasuredRadiusScaleOptions;
  arc?: StrokeStyleDetails & { innerRadius?: ArcInnerRadius; padAngle?: 0; fill?: string; opacity?: number; stroke?: string; strokeWidth?: number };
  guides?: false | MeasuredRadialGuideOptions;
} & ({ value?: never; aggregate?: "count" } | { value: string; aggregate?: "sum" });

`CreateRugPlotOptions`

Expand CreateRugPlotOptions

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" }
);

Related types: RugTickOptions · RugGuideOptions · RugMeasureChannel.

`CreateScaleOptions`

Expand CreateScaleOptions

export type CreateScaleOptions = ScaleOptions & { id: string };

Related types: ScaleOptions.

`CreateScatterPlotOptions`

Expand CreateScatterPlotOptions

export interface CreateScatterPlotOptions {
  /** Forward the native mark missing-value policy. */
  missing?: "error" | "skip";
  id?: string;
  data?: string;
  coordinate?: string;
  x: PointFacadePositionChannel;
  y: PointFacadePositionChannel;
  color?: BasicColorChannel;
  stroke?: string | WithoutEncodingTarget<Extract<StrokeEncodingOptions, { field: string }>>;
  size?: BasicSizeChannel;
  shape?: BasicShapeChannel;
  point?: StrokeStyleDetails & {
    clip?: boolean;
    radius?: number;
    shape?: PointShape;
    fill?: string;
    opacity?: number;
    stroke?: FilledMarkStroke;
    strokeWidth?: number;
  };
  guides?: false | CartesianGuideOptions;
}

`CreateStatisticalReferenceOptions`

Expand CreateStatisticalReferenceOptions

export type CreateStatisticalReferenceOptions = DynamicReferenceBinding & (
  | (RuleStyleOptions & { readonly statistic?: ReferenceStatistic; readonly statistics?: never })
  | (Omit<RectMarkOptions, "id" | "data" | "source" | "missing"> & {
      readonly statistics: readonly [ReferenceStatistic, ReferenceStatistic]; readonly statistic?: never;
    })
);

`CreateStripPlotOptions`

Expand CreateStripPlotOptions

export type CreateStripPlotOptions = {
  id?: string;
  data?: string;
  coordinate?: string;
  color?: BasicColorChannel;
  size?: BasicSizeChannel;
  shape?: BasicShapeChannel;
  point?: StrokeStyleDetails & {
    clip?: boolean;
    radius?: number;
    shape?: PointShape;
    fill?: string;
    opacity?: number;
    stroke?: FilledMarkStroke;
    strokeWidth?: number;
  };
  guides?: false | CartesianGuideOptions;
} & (
  | { x: RugMeasureChannel; y?: never; jitter?: false | StripPixelJitterOptions }
  | { x: RugMeasureChannel; y: StripCategoryChannel; jitter?: false | StripBandJitterOptions }
  | { x: StripCategoryChannel; y: RugMeasureChannel; jitter?: false | StripBandJitterOptions }
);

`CreateTextPlotOptions`

Expand CreateTextPlotOptions

export interface CreateTextPlotOptions {
  id?: string;
  data?: string;
  coordinate?: string;
  x: TextPlotPositionChannel;
  y: TextPlotPositionChannel;
  text: string | WithoutEncodingTarget<Extract<TextEncodingOptions, { field: string } | { value: unknown }>>;
  color?: RectColorChannel;
  style?: Omit<TextMarkOptions, "id" | "data" | "source" | "text" | "inheritColor">;
  guides?: false | ColorGuides;
}

`CreateThetaAxisLabelsOptions`

Expand CreateThetaAxisLabelsOptions

export type CreateThetaAxisLabelsOptions = Omit<PolarLabelOptions, "count" | "values"> &
  PolarAxisTickSelection & Omit<PolarGuideResourceOptions, "angle"> &
  DisplayLabelOptions;

`CreateThetaAxisLineOptions`

Expand CreateThetaAxisLineOptions

export type CreateThetaAxisLineOptions = AxisLineStyleOptions &
  Omit<PolarGuideResourceOptions, "angle">;

`CreateThetaAxisTicksOptions`

Expand CreateThetaAxisTicksOptions

export type CreateThetaAxisTicksOptions = Omit<PolarTickOptions, "count" | "values"> &
  PolarAxisTickSelection & Omit<PolarGuideResourceOptions, "angle">;

`CreateThetaAxisTitleOptions`

Expand CreateThetaAxisTitleOptions

export type CreateThetaAxisTitleOptions = PolarTitleOptions &
  Omit<PolarGuideResourceOptions, "angle">;

Related types: PolarTitleOptions · PolarGuideResourceOptions.

`CurveInterpolation`

Expand CurveInterpolation

export type CurveInterpolation =
  | "linear"
  | "step"
  | "step-before"
  | "step-after"
  | "basis"
  | "cardinal"
  | "monotone"
  | "monotone-steffen"
  | "natural";

`DashPattern`

Expand DashPattern

export type DashPattern = readonly number[];

`DashScaleOptions`

Expand DashScaleOptions

export interface DashScaleOptions {
  id?: string;
  type?: "ordinal";
  domain?: "auto" | readonly unknown[];
  range?: "auto" | readonly (DashStyle | DashPattern)[];
  unknown?: DashStyle | DashPattern;
}

Related types: DashStyle · DashPattern.

`DashStyle`

Expand DashStyle

export type DashStyle = "solid" | "dashed" | "dotted" | "dashdot";

`DatasetBin2DOutputFields`

Expand DatasetBin2DOutputFields

export interface DatasetBin2DOutputFields {
  readonly x0: string;
  readonly x1: string;
  readonly y0: string;
  readonly y1: string;
  readonly count: string;
  readonly members?: string;
}

`DatasetBin2DTransform`

Expand DatasetBin2DTransform

export interface DatasetBin2DTransform {
  readonly type: "bin2d";
  readonly assignment?: "step";
  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;
  };
}

Related types: Bin2DCounts · DatasetBin2DOutputFields.

`DatasetBinTransform`

Expand DatasetBinTransform

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 missing?: "error" | "drop";
  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[]];
  };
}

Related types: StatisticalWeight.

`DatasetCompleteTransform`

Expand DatasetCompleteTransform

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 }
);

Related types: DatasetScalar.

`DatasetComputedTransform`

Expand DatasetComputedTransform

export interface DatasetComputedTransform {
  readonly type: "computed";
  readonly as: string;
  readonly expression: ComputedExpression;
}

Related types: ComputedExpression.

`DatasetDensityTransform`

Expand DatasetDensityTransform

export interface DatasetDensityTransform {
  type: "density";
  field: string;
  groupBy?: string;
  bandwidth: "auto" | number;
  extent: "auto" | readonly [number, number];
  steps: number;
  kernel?: DensityKernel;
  normalization?: DensityNormalization;
  weight?: StatisticalWeight;
  missing?: "error" | "drop";
  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 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;
        }[];
      }
  );
}

`DatasetECDFResolvedGroup`

Expand DatasetECDFResolvedGroup

export interface DatasetECDFResolvedGroup {
  readonly keys: Readonly<Record<string, string | number | boolean>>;
  readonly denominator: number;
  readonly validCount: number;
}

`DatasetECDFTransform`

Expand DatasetECDFTransform

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[];
  };
}

Related types: ECDFOutputFields · DatasetECDFResolvedGroup.

`DatasetFilterTransform`

Expand DatasetFilterTransform

export type DatasetFilterTransform = {
  type: "filter";
  field: string;
  nulls?: "include" | "exclude";
} & (
  | { oneOf: readonly DatasetScalar[]; noneOf?: never; predicate?: never; range?: never }
  | { oneOf?: never; noneOf: readonly DatasetScalar[]; predicate?: never; range?: never }
  | { oneOf?: never; noneOf?: never; predicate: FilterComparison; range?: never }
  | { oneOf?: never; noneOf?: never; predicate?: never; range: FilterRange }
);

Related types: DatasetScalar · FilterComparison · FilterRange.

`DatasetFlattenTransform`

Expand DatasetFlattenTransform

export interface DatasetFlattenTransform {
  readonly type: "flatten";
  readonly fields: readonly string[];
  readonly as: readonly string[];
}

`DatasetFoldTransform`

Expand DatasetFoldTransform

export interface DatasetFoldTransform {
  readonly type: "fold";
  readonly fields: readonly string[];
  readonly as: {
    readonly key: string;
    readonly value: string;
  };
}

`DatasetHorizonTransform`

Expand DatasetHorizonTransform

export interface DatasetHorizonTransform {
  readonly type: "horizon";
  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";
  };
  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;
    }[];
  };
}

`DatasetImputedBaseTransform`

Expand DatasetImputedBaseTransform

type DatasetImputedBaseTransform = {
  readonly type: "impute";
  readonly fields: readonly string[];
  readonly groupBy: readonly string[];
  readonly edges: "keep" | "error";
  readonly maxGap?: number;
};

`DatasetImputedTransform`

Expand DatasetImputedTransform

export type DatasetImputedTransform = DatasetImputedBaseTransform & (
  | { readonly method: "mean"; readonly value?: never; readonly sortBy: readonly DatasetWindowSort[]; }
  | {
      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" }];
    }
);

`DatasetIntervalOutputFields`

Expand DatasetIntervalOutputFields

export interface DatasetIntervalOutputFields {
  center: string;
  lower: string;
  upper: string;
}

`DatasetIntervalTransform`

Expand DatasetIntervalTransform

export type DatasetIntervalTransform = {
  type: "interval";
  field: string;
  groupBy: readonly string[];
  as: DatasetIntervalOutputFields;
  missing?: "error" | "drop";
} & (
  | {
      center: "mean";
      extent: "stderr" | "stdev";
      method?: never;
      level?: never;
    }
  | {
      center: "mean";
      extent: "ci";
      method?: MeanConfidenceIntervalMethod;
      level: number;
    }
  | {
      center: "median";
      extent: "iqr";
      method?: never;
      level?: never;
    }
);

`DatasetLookupTransform`

Expand DatasetLookupTransform

export interface DatasetLookupTransform {
  readonly type: "lookup";
  readonly field: string;
  readonly lookup: {
    readonly data: string;
    readonly key: string;
    readonly fields: readonly string[];
    readonly as: readonly string[];
  };
}

`DatasetNormalizeBaselineTransform`

Expand DatasetNormalizeBaselineTransform

type DatasetNormalizeBaselineTransform = {
  readonly baseline: NormalizeBaseline;
  readonly sortBy: readonly WindowSort[];
};

Related types: NormalizeBaseline · WindowSort.

`DatasetNormalizedBaseTransform`

Expand DatasetNormalizedBaseTransform

type DatasetNormalizedBaseTransform = {
  readonly type: "normalize";
  readonly field: string;
  readonly as: string;
  readonly groupBy: readonly string[];
};

`DatasetNormalizedTransform`

Expand DatasetNormalizedTransform

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)
);

`DatasetRegressionStatisticsTransform`

Expand DatasetRegressionStatisticsTransform

export interface DatasetRegressionStatisticsTransform {
  readonly type: "regressionStatistics";
}

`DatasetRegressionTransform`

Expand DatasetRegressionTransform

export type DatasetRegressionTransform = {
  type: "regression";
  x: string;
  y: string;
  groupBy?: string;
} & (
  | ({
      method: "linear";
      degree?: never;
      span?: never;
      robustIterations?: never;
    } & ({ interval: false; confidenceMethod?: never; level?: never; confidence?: never } | ({ interval: "mean" | "prediction" } & (
      | { confidenceMethod: ConfidenceIntervalMethod; level: number; confidence?: never }
      | { confidence: number; confidenceMethod?: never; level?: never }
    ))))
  | ({
      method: "polynomial";
      degree: number;
      span?: never;
      robustIterations?: never;
    } & ({ interval: false; confidenceMethod?: never; level?: never; confidence?: never } | ({ interval: "mean" | "prediction" } & (
      | { confidenceMethod: ConfidenceIntervalMethod; level: number; confidence?: never }
      | { confidence: number; confidenceMethod?: never; level?: never }
    ))))
  | {
      method: "exp";
      interval: false;
      degree?: never;
      span?: never;
      robustIterations?: never;
      confidenceMethod?: never;
      level?: never;
      confidence?: never;
    }
  | {
      method: "loess";
      span: number;
      robustIterations?: number;
      degree?: never;
      confidenceMethod?: never;
      level?: never;
      confidence?: never;
      interval?: never;
    }
) & { readonly predict?: RegressionPredictOptions; readonly missing?: "error" | "drop" };

`DatasetScalar`

Expand DatasetScalar

export type DatasetScalar = string | number | boolean | null;

`DatasetSortTransform`

Expand DatasetSortTransform

export interface DatasetSortTransform {
  readonly type: "sort";
  readonly sortBy: readonly {
    readonly field: string;
    readonly order: "ascending" | "descending";
    readonly nulls: "first" | "last";
    readonly temporalUnit?: "year" | "timestamp";
  }[];
}

`DatasetStackTransform`

Expand DatasetStackTransform

export interface DatasetStackTransform {
  readonly type: "stack";
  readonly category: string;
  readonly group: string;
  readonly value: string;
  readonly mode: StackDataMode;
  readonly as: Required<StackDataOutputFields>;
}

Related types: StackDataMode · StackDataOutputFields.

`DatasetStatisticalReferenceTransform`

Expand DatasetStatisticalReferenceTransform

interface DatasetStatisticalReferenceTransform {
  readonly type: "statisticalReference";
  readonly target: string;
}

`DatasetStorageType`

Expand DatasetStorageType

export type DatasetStorageType =
  | "number"
  | "string"
  | "boolean"
  | "array"
  | "object"
  | "unknown"
  | "mixed";

`DatasetSummaryTransform`

Expand DatasetSummaryTransform

export interface DatasetSummaryTransform {
  type: "summary";
  groupBy: readonly string[];
  aggregates: readonly SummaryAggregateOptions[];
  members?: string;
  weight?: StatisticalWeight;
  missing?: "error" | "drop";
  empty?: "null" | "identity";
}

Related types: SummaryAggregateOptions · StatisticalWeight.

`DatasetTimeUnitTransform`

Expand DatasetTimeUnitTransform

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";
    }
);

Related types: DatasetTimeUnitTransformBase · TimeUnit.

`DatasetTimeUnitTransformBase`

Expand DatasetTimeUnitTransformBase

type DatasetTimeUnitTransformBase = {
  readonly missing?: "error" | "null";
  readonly type: "timeUnit";
  readonly field: string;
  readonly temporalUnit?: TemporalInputUnit;
  readonly as: string;
  readonly timeZone?: string;
};

Related types: TemporalInputUnit.

`DatasetTransform`

Expand DatasetTransform

export type DatasetTransform =
  | DatasetBinTransform
  | DatasetBin2DTransform
  | DatasetCompleteTransform
  | DatasetComputedTransform
  | DatasetImputedTransform
  | DatasetNormalizedTransform
  | DatasetFilterTransform
  | DatasetFlattenTransform
  | DatasetLookupTransform
  | DatasetFoldTransform
  | DatasetRegressionTransform
  | DatasetRegressionStatisticsTransform
  | DatasetSortTransform
  | DatasetDensityTransform
  | DatasetECDFTransform
  | DatasetHorizonTransform
  | DatasetIntervalTransform
  | DatasetSummaryTransform
  | DatasetStackTransform
  | DatasetStatisticalReferenceTransform
  | DatasetTimeUnitTransform
  | DatasetWindowTransform;

`DatasetWindowOperation`

Expand DatasetWindowOperation

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;
    }
  | {
      readonly op: "movingMean" | "movingSum";
      readonly field: string;
      readonly as: string;
      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";
    };

Related types: DurationWindowUnit.

`DatasetWindowSort`

Expand DatasetWindowSort

export interface DatasetWindowSort {
  readonly field: string;
  readonly order: WindowSortOrder;
}

Related types: WindowSortOrder.

`DatasetWindowTransform`

Expand DatasetWindowTransform

export interface DatasetWindowTransform {
  readonly type: "window";
  readonly partitionBy: readonly string[];
  readonly sortBy: readonly DatasetWindowSort[];
  readonly operations: readonly DatasetWindowOperation[];
  readonly temporalUnit?: TemporalInputUnit;
}

`DatumPositionEncodingOptions`

Expand DatumPositionEncodingOptions

export type DatumPositionEncodingOptions =
  | InferredRuleDatumPositionEncodingOptions
  | RulePositionEncodingBase & (
    | {
        fieldType: "quantitative";
        scale?: NonPointQuantitativePositionScaleOptions;
      }
    | {
        fieldType: "temporal";
        temporalUnit?: TemporalInputUnit;
        scale?: NonPointTemporalPositionScaleOptions;
      }
    | {
        fieldType: "nominal" | "ordinal";
        scale?: NonPointCategoricalPositionScaleOptions;
      }
    );

/** Constant primary position accepted by Rule, Rect, Area, Point, Tick, and independent Text policies. */

`DensityDataOptions`

Expand DensityDataOptions

export interface DensityDataOptions {
  id: string;
  source?: string;
  field: string;
  groupBy?: string;
  bandwidth?: "auto" | number;
  extent?: "auto" | readonly [number, number];
  steps?: number;
  kernel?: DensityKernel;
  normalization?: DensityNormalization;
  weight?: StatisticalWeight;
  missing?: "error" | "drop";
  as?: readonly [string, string];
}

`DensityEncodingBase`

Expand DensityEncodingBase

type DensityEncodingBase = Omit<DensityDataOptions, "id" | "groupBy"> & {
  groupBy?: string | false;
  target?: string;
  densityChannel?: "x" | "y";
  coordinate?: string;
  valueScale?: NonPointQuantitativePositionScaleOptions;
};

`DensityEncodingOptions`

Expand DensityEncodingOptions

export type DensityEncodingOptions = DensityEncodingBase & (
  | {
      placement?: BaselineDensityPlacement;
      densityScale?: NonPointZeroSupportingPositionScaleOptions;
    }
  | {
      placement: CategoryDensityPlacement;
      densityScale?: never;
    }
);

`DensityKernel`

Expand DensityKernel

export type DensityKernel =
  | "gaussian"
  | "epanechnikov"
  | "uniform"
  | "triangular";

`DensityNormalization`

Expand DensityNormalization

export type DensityNormalization = "unit" | "count";

`DensityPlacement`

Expand DensityPlacement

export type DensityPlacement =
  | BaselineDensityPlacement
  | CategoryDensityPlacement;

`DensityPlacementSide`

Expand DensityPlacementSide

export type DensityPlacementSide =
  | "both"
  | "left"
  | "right"
  | "top"
  | "bottom";

`DensityPlacementSplit`

Expand DensityPlacementSplit

export interface DensityPlacementSplit {
  field: string;
  domain?: readonly [unknown, unknown];
}

`DensityPlacementWidth`

Expand DensityPlacementWidth

export interface DensityPlacementWidth {
  band?: number;
  resolve?: DensityWidthResolution;
}

Related types: DensityWidthResolution.

`DensityPlotGuideOptions`

Expand DensityPlotGuideOptions

export type DensityPlotGuideOptions = Omit<CCategoricalGuides, "legend" | "grid"> & {
  grid?: false | ContinuousCartesianGridOptions;
  legend?: false | DensityPlotLegendOptions;
};

`DensityPlotLegendOptions`

Expand DensityPlotLegendOptions

export type DensityPlotLegendOptions = Omit<PieLegendOptions, "order"> & { order?: LegendValueOrder };

Related types: PieLegendOptions · LegendValueOrder.

`DensityWidthResolution`

Expand DensityWidthResolution

export type DensityWidthResolution = "shared" | "independent";

`DerivedDataDependents`

Expand DerivedDataDependents

export type DerivedDataDependents = "reject" | "recompute";

`DiscretizedColorScaleOptions`

Expand DiscretizedColorScaleOptions

export type DiscretizedColorScaleOptions =
  | QuantizeColorScaleOptions
  | QuantileColorScaleOptions
  | ThresholdColorScaleOptions;

/** Area quantitative color requires one finite value per existing series;
 * aggregate, temporal color and unknown fallback remain mark-specific restrictions.
 * Area authoring uses the Full facade; createAreaPlot.color stays categorical.
 * Tick quantitative/temporal color paints its stroke and excludes a simultaneous stroke encoding.
 */

`DisplayLabelMap`

Expand DisplayLabelMap

export type DisplayLabelMap = ReadonlyArray<Readonly<{
  value: DatasetScalar;
  label: string;
}>>;

Related types: DatasetScalar.

`DisplayLabelOptions`

Expand DisplayLabelOptions

export interface DisplayLabelOptions {
  labelMap?: DisplayLabelMap | "auto";
}

Related types: DisplayLabelMap.

`DistributiveLegendOmit`

Expand DistributiveLegendOmit

type DistributiveLegendOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;

`DurationWindowFrame`

Expand DurationWindowFrame

export type DurationWindowFrame = {
  preceding?: never;
  following?: never;
  duration: {
    preceding: number;
    following?: number;
    unit: DurationWindowUnit;
  };
};

Related types: DurationWindowUnit.

`DurationWindowUnit`

Expand DurationWindowUnit

export type DurationWindowUnit = "millisecond" | "second" | "minute" | "hour" | "day";

`DynamicReferenceBinding`

Expand DynamicReferenceBinding

type DynamicReferenceBinding = {
  readonly id?: string;
  readonly source: string;
  readonly axis: "x" | "y";
  /** Distribution/endpoint measurement axes and quantitative Horizon X use original bound observations, retaining multiplicity. Horizon folded Y is unsupported. */
  readonly population?: "boundData" | "visibleItems";
  readonly field?: string;
  /** Compute a separate reference for each observed value of this field. */
  readonly groupBy?: string;
  readonly x?: never;
  readonly y?: never;
  readonly space?: never;
  readonly data?: never;
  readonly coordinate?: never;
  readonly temporalUnit?: never;
};
/** A statistical line (mean by default) or an exact two-statistic interval. */

`ECDFDataOptions`

Expand ECDFDataOptions

export interface ECDFDataOptions {
  id: string;
  source?: string;
  field: string;
  groupBy?: string | readonly [string, ...string[]];
  weight?: string;
  missing?: "drop" | "error";
  as?: ECDFOutputFields;
}

Related types: ECDFOutputFields.

`ECDFOutputFields`

Expand ECDFOutputFields

export interface ECDFOutputFields {
  value: string;
  cumulative: string;
  probability: string;
}

`EditAxesOptions`

Expand EditAxesOptions

export interface EditAxesOptions {
  x?: false | EditAxisOptions<XAxisPosition> | readonly [EditAxisOptions<XAxisPosition> & { target: string }, ...(EditAxisOptions<XAxisPosition> & { target: string })[]];
  y?: false | EditAxisOptions<YAxisPosition> | readonly [EditAxisOptions<YAxisPosition> & { target: string }, ...(EditAxisOptions<YAxisPosition> & { target: string })[]];
  theta?: false | EditThetaAxisOptions;
  radius?: false | EditRadialAxisOptions;
  parallel?: false | EditParallelAxisOptions | readonly [EditParallelAxisOptions, ...EditParallelAxisOptions[]];
}

`EditAxisOptions`

Expand EditAxisOptions

export interface EditAxisOptions<P extends string> {
  /** Omission preserves placement; false restores the ordinary overlay. */
  underlay?: boolean;
  target?: string;
  /** Omitted edits preserve the frame; zero restores the plot-edge frame. */
  offset?: number;
  position?: P;
  line?: false | AxisLineStyleOptions;
  ticks?: false | Omit<AxisTickOptions<P>, "scale" | "position" | "target">;
  labels?: false | Omit<AxisLabelOptions<P>, "scale" | "position" | "target">;
  ticksAndLabels?: false | Omit<AxisTicksAndLabelsOptions<P>, "scale" | "position" | "target">;
  title?: false | Omit<AxisTitleOptions<P>, "scale" | "position" | "target">;
}

`EditBin2DDataOptions`

Expand EditBin2DDataOptions

export interface EditBin2DDataOptions {
  target?: string;
  source?: string;
  x?: string;
  y?: string;
  bins?: number | Bin2DCounts;
  extent?: Bin2DExtent;
  assignment?: "edges" | "step";
  includeEmpty?: boolean;
  members?: boolean;
  as?: DatasetBin2DOutputFields;
  dependents?: DerivedDataDependents;
}

`EditBinDataOptions`

Expand EditBinDataOptions

export type EditBinDataOptions = FocusedWeightedDerivedDataEdit<
  BinDataOptions,
  StatisticalWeight
>;

`EditBoxPlotOptions`

Expand EditBoxPlotOptions

export interface EditBoxPlotOptions {
  summary?: BoxPlotSummaryFields | false;
  target?: string;
  data?: string;
  x?: BoxPlotPositionChannel;
  y?: BoxPlotPositionChannel;
  whisker?: BoxPlotWhisker;
  width?: BoxPlotWidth;
  outliers?: boolean;
  box?: RectStyleDetails & {
    fill?: string;
    opacity?: number;
    stroke?: string;
    strokeWidth?: number;
  };
  median?: StrokeStyleDetails & {
    width?: { pixels: number } | "auto";
    stroke?: string;
    strokeWidth?: number;
  };
  outlier?: StrokeStyleDetails & {
    shape?: PointShape;
    radius?: number;
    opacity?: number;
  };
}

`EditColorScaleOptions`

Expand EditColorScaleOptions

export type EditColorScaleOptions = FocusedScaleSelection & WithoutScaleId<
  CategoricalColorScaleOptions | Omit<ContinuousColorScaleOptions, "whitePoint" | "gamma"> | DiscretizedColorScaleOptions
> & { whitePoint?: "d65" | "d50" | "auto"; gamma?: number | "auto" };

`EditCompleteDataOptions`

Expand EditCompleteDataOptions

export type EditCompleteDataOptions = FocusedDerivedDataEdit<CompleteDataOptions>;

Related types: FocusedDerivedDataEdit · CompleteDataOptions.

`EditCompositionLayoutOptions`

Expand EditCompositionLayoutOptions

export interface EditCompositionLayoutOptions {
  columns?: number;
  gap?: FacetGap;
  align?: CompositionAlign;
  padding?: number | CompositionPadding;
  /** Interpret gap between child canvases (default), inner plots, or retained full content (wrapped facets). */
  spacing?: "canvas" | "plot" | "content";
  /** Share existing top margin with parent title and headers; requires plot spacing. Stacked restores the default. */
  topLane?: FacetTopLaneMode;
}

`EditComputedDataOptions`

Expand EditComputedDataOptions

export type EditComputedDataOptions = FocusedDerivedDataEdit<ComputedDataOptions>;

Related types: FocusedDerivedDataEdit · ComputedDataOptions.

`EditCoordinateOptions`

Expand EditCoordinateOptions

export type EditCoordinateOptions = EditCoordinateTarget & (
  | { aspect: CoordinateAspect; polarFrame?: PolarFrameOptions }
  | { aspect?: CoordinateAspect; polarFrame: PolarFrameOptions }
);

`EditCoordinateTarget`

Expand EditCoordinateTarget

type EditCoordinateTarget = {
  target: string;
};

`EditDensityDataOptions`

Expand EditDensityDataOptions

export type EditDensityDataOptions = FocusedWeightedDerivedDataEdit<
  DensityDataOptions,
  StatisticalWeight
>;

`EditDensityOptions`

Expand EditDensityOptions

export interface EditDensityOptions {
  target?: string;
  source?: string;
  field?: string;
  groupBy?: string | false;
  bandwidth?: "auto" | number;
  extent?: "auto" | readonly [number, number];
  steps?: number;
  kernel?: DensityKernel;
  normalization?: DensityNormalization;
  weight?: StatisticalWeight | false;
  densityChannel?: "x" | "y";
  valueScale?: NonPointQuantitativePositionScaleOptions;
  placement?: DensityPlacement;
}

`EditDerivedDataOptions`

Expand EditDerivedDataOptions

export interface EditDerivedDataOptions {
  target: string;
  definition: RequestedDatasetTransform;
  dependents?: DerivedDataDependents;
}

`EditECDFDataOptions`

Expand EditECDFDataOptions

export type EditECDFDataOptions = FocusedWeightedDerivedDataEdit<
  ECDFDataOptions,
  string
>;

`EditECDFPlotOptions`

Expand EditECDFPlotOptions

export type EditECDFPlotOptions = { target?: string } & Partial<Pick<
  CreateECDFPlotOptions,
  "data" | "coordinate" | "field" | "missing" | "as"
>> & {
  groupBy?: CreateECDFPlotOptions["groupBy"] | false;
  weight?: string | false;
  color?: CreateECDFPlotOptions["color"] | false;
};

Related types: CreateECDFPlotOptions.

`EditEndpointPlotOptions`

Expand EditEndpointPlotOptions

export type EditEndpointPlotOptions = { target?: string } & Partial<Pick<
  CreateDumbbellPlotOptions,
  "data" | "coordinate" | "category" | "start" | "end" | "orientation" | "summary"
>> & {
  value?: EndpointValueChannel;
  baseline?: number;
};

`EditErrorBandBoundaryOptions`

Expand EditErrorBandBoundaryOptions

export interface EditErrorBandBoundaryOptions extends StrokeStyleDetails {
  target?: string;
  boundary?: "both" | "lower" | "upper";
  stroke?: string;
  strokeWidth?: number;
  strokeDash?: DashStyle | DashPattern;
  opacity?: number;
  curve?: CurveInterpolation;
}

Related types: StrokeStyleDetails · DashStyle · DashPattern · CurveInterpolation.

`EditErrorBandOptions`

Expand EditErrorBandOptions

export interface EditErrorBandOptions extends StrokeStyleDetails {
  target?: string;
  data?: string;
  x?: ErrorBandPositionChannel | ErrorBandIntervalChannel;
  y?: ErrorBandPositionChannel | ErrorBandIntervalChannel;
  groupBy?: string | false;
  fill?: FillPaint | false;
  opacity?: number;
  curve?: CurveInterpolation;
  statistics?: {
    center?: IntervalCenter;
    extent?: IntervalExtent;
    method?: ConfidenceIntervalMethod;
    level?: number;
  };
  boundaries?: false | (StrokeStyleDetails & {
    stroke?: string;
    strokeWidth?: number;
    strokeDash?: DashStyle | DashPattern;
    opacity?: number;
    curve?: CurveInterpolation;
  });
}

`EditErrorBarOptions`

Expand 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;
  strokeWidth?: number;
  strokeDash?: DashStyle | DashPattern;
  opacity?: number;
  statistics?: {
    center?: IntervalCenter;
    extent?: IntervalExtent;
    method?: ConfidenceIntervalMethod;
    level?: number;
  };
}

`EditFacetHeadersOptions`

Expand EditFacetHeadersOptions

export interface EditFacetHeadersOptions {
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
  color?: string;
  offset?: number;
  /** Content follows concrete mark bounds with plot spacing; plot preserves existing placement. */
  anchor?: "plot" | "content" | "view";
  role?: FacetHeaderRole;
  labelMap?: DisplayLabelMap | "auto";
  side?: FacetHeaderSide;
  align?: FacetHeaderAlign;
  /** Numbers are radians; zero restores the existing unrotated header layout. */
  rotation?: RotationInput;
  /** Requires an explicit row or column role. False removes that role's field title. */
  title?: FacetHeaderTitleOptions | false;
}

`EditFacetSourceOptions`

Expand EditFacetSourceOptions

export type EditFacetSourceOptions =
  | { program: ChartProgram; action?: never }
  | { program?: never; action: { method: string; options?: Readonly<Record<string, unknown>> } };

`EditFilteredDataOptions`

Expand EditFilteredDataOptions

export type EditFilteredDataOptions = FilterModePatch & {
  target: string;
  field?: string;
  nulls?: "include" | "exclude" | false;
  dependents?: DerivedDataDependents;
};

Related types: FilterModePatch · DerivedDataDependents.

`EditFlattenDataOptions`

Expand EditFlattenDataOptions

export type EditFlattenDataOptions = FocusedDerivedDataEdit<FlattenDataOptions>;

Related types: FocusedDerivedDataEdit · FlattenDataOptions.

`EditFoldDataOptions`

Expand EditFoldDataOptions

export type EditFoldDataOptions = FocusedDerivedDataEdit<FoldDataOptions>;

Related types: FocusedDerivedDataEdit · FoldDataOptions.

`EditGradientPlotOptions`

Expand EditGradientPlotOptions

export interface EditGradientPlotOptions {
  target?: string;
  data?: string;
  x?: GradientPlotPositionChannel;
  y?: GradientPlotPositionChannel;
  density?: GradientPlotDensityOptions;
  width?: { band?: number };
  gradient?: GradientPlotAppearanceOptions;
  center?: false | GradientPlotCenterOptions;
}

`EditGraphicsOptions`

Expand EditGraphicsOptions

export type EditGraphicsOptions =
  | { target: string; property: string; value: unknown; remove?: false }
  | { target: string; remove: true; property?: never; value?: never };

`EditGridDirectionsOptions`

Expand EditGridDirectionsOptions

export interface EditGridDirectionsOptions {
  horizontal?: EditGridOptions;
  vertical?: EditGridOptions;
  theta?: EditPolarGridOptions;
  radial?: EditPolarGridOptions;
}

Related types: EditGridOptions · EditPolarGridOptions.

`EditGridOptions`

Expand EditGridOptions

export interface EditGridOptions {
  strokeDashMap?: CartesianGuideDashMap | "auto";
  /** Absolute signed logical-pixel displacement; omission preserves the current value. */
  alongOffset?: number;
  /** Preserve omitted order; finite values sort Cartesian grids relative to marks at zero. */
  zIndex?: number;
  /** Band centers by default; boundary draws both edges of each selected band. */
  bandPosition?: "center" | "boundary";
  count?: number;
  values?: readonly CategoryValue[] | "auto";
  color?: string;
  lineWidth?: number;
  strokeDash?: readonly number[];
}

Related types: CartesianGuideDashMap · CategoryValue.

`EditHorizonOptions`

Expand EditHorizonOptions

export interface EditHorizonOptions
  extends Omit<HorizonEncodingOptions, "groupBy"> {
  groupBy?: string | false;
}

Related types: HorizonEncodingOptions.

`EditImputedDataOptions`

Expand EditImputedDataOptions

export type EditImputedDataOptions = FocusedDerivedDataEdit<ImputedDataOptions>;

Related types: FocusedDerivedDataEdit · ImputedDataOptions.

`EditIntervalDataOptions`

Expand EditIntervalDataOptions

export type EditIntervalDataOptions = FocusedDerivedDataEdit<IntervalDataOptions>;

Related types: FocusedDerivedDataEdit · IntervalDataOptions.

`EditLegendBlockOptions`

Expand EditLegendBlockOptions

export interface EditLegendBlockOptions {
  /** Reset only the sample window with auto. */
  clipHeight?: number | "auto";
  target: string;
  channel: LegendChannel;
  /** Block-local anchor; inherit removes only this override. */
  position?: "right" | "left" | "bottom" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "inherit";
  title?: string;
  values?: readonly [number, ...number[]] | "auto";
  count?: number;
  order?: readonly CategoryValue[];
  gap?: number;
  text?: LegendBlockTextPatch;
  symbol?: LegendBlockSymbolPatch;
  /** Display-only: categorical keys, or finite numeric keys for continuous size samples. Empty labels omit text only. */
  labelMap?: DisplayLabelMap | "auto";
}

`EditLegendBorderOptions`

Expand EditLegendBorderOptions

export interface EditLegendBorderOptions {
  target?: string;
  /** Select one existing block without changing its content. */
  channel?: LegendChannel;
  border: boolean | LegendBorderOptions;
}

/** Omitted/false axes are preserved; component false values remove existing components. */

Related types: LegendChannel · LegendBorderOptions.

`EditLegendLabelsOptions`

Expand EditLegendLabelsOptions

export interface EditLegendLabelsOptions extends LegendTextOptions {
  target?: string;
  /** Select one existing block without changing its content. */
  channel?: LegendChannel;
}

Related types: LegendTextOptions · LegendChannel.

`EditLegendLayoutOptions`

Expand EditLegendLayoutOptions

export interface EditLegendLayoutOptions {
  target?: string;
  /** Select one existing block without changing its content. */
  channel?: LegendChannel;
  layout?: "edge" | "legacy-bottom";
  /** Outside right/left: complete legend stack top aligns with the plot top, including borders and excluding chart titles. */
  position?: "right" | "left" | "bottom" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "inherit";
  /** Opt into whole-target legend group layout; a requested row never wraps. */
  blockLayout?: "row" | "column" | "wrap";
  /** Move the complete occupied group top-left to plot-relative logical pixels. A later position clears this anchor. */
  at?: { x: number; y: number };
  /** Single top/bottom edge: align complete occupied bounds, including border strokes, to the plot. Side positions require center. */
  align?: "left" | "center" | "right";
  /** Gradient orientation is independent of position; auto is gradient-only. Categorical sides require vertical. */
  direction?: "horizontal" | "vertical" | "auto";
  /** Categorical legends accept a positive column count on every supported position. */
  columns?: number;
  /** Single top/bottom edge: gap from the plot to the nearest occupied legend edge. */
  offset?: number;
  /** bottom is gradient-only; left retains the existing categorical/opacity rules. */
  titlePosition?: "top" | "left" | "bottom";
  /** Explicit spacing override; vertical creation defaults to 18 logical pixels. */
  itemGap?: number;
  /** Non-negative occupied-row gap; auto restores the retained legacy pitch. */
  rowPadding?: number | "auto";
  /** Non-negative visible-title/body gap; auto restores the family default. */
  titlePadding?: number | "auto";
}

Related types: LegendChannel.

`EditLegendOptions`

Expand EditLegendOptions

export interface EditLegendOptions
  extends Omit<LegendOptions, "title" | "values" | "titleStyle" | "direction" | "position" | "clipHeight" | "rowPadding" | "titlePadding"> {
  clipHeight?: number | "auto";
  /** auto removes the row policy and restores the retained itemGap behavior. */
  rowPadding?: number | "auto";
  /** auto removes the title/body spacing override. */
  titlePadding?: number | "auto";
  /** Select one existing block; cannot accompany channels. */
  channel?: LegendChannel;
  /** inherit is allowed only with a singular channel selector. */
  position?: "right" | "left" | "bottom" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "inherit";
  /** Gradient-only auto resets orientation. */
  direction?: "horizontal" | "vertical" | "auto";
  titleStyle?: LegendTitleStyleEditOptions;
  /** 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";
}

`EditLegendSymbolsOptions`

Expand EditLegendSymbolsOptions

export interface EditLegendSymbolsOptions {
  clipHeight?: number | "auto";
  target?: string;
  /** Select one existing block without changing its content. */
  channel?: LegendChannel;
  symbol?: LegendSymbolRecipe;
  count?: number;
  gradient?: { length?: number; thickness?: number; opacity?: number };
}

Related types: LegendChannel · LegendSymbolRecipe.

`EditLegendTitleOptions`

Expand EditLegendTitleOptions

export interface EditLegendTitleOptions extends LegendTitleStyleEditOptions {
  target?: string;
  /** Select one existing block without changing its content. */
  channel?: LegendChannel;
  title?: string | "auto" | false;
}

Related types: LegendTitleStyleEditOptions · LegendChannel.

`EditLookupDataOptions`

Expand EditLookupDataOptions

export type EditLookupDataOptions = FocusedDerivedDataEdit<LookupDataOptions>;

Related types: FocusedDerivedDataEdit · LookupDataOptions.

`EditMarkLabelPlacementOptions`

Expand EditMarkLabelPlacementOptions

export interface EditMarkLabelPlacementOptions {
  target: string;
  placement: MarkLabelPlacement | "auto";
}

/** Remove one attached label layer or every attached label owned by a source mark. */

Related types: MarkLabelPlacement.

`EditMarkLabelSelectionOptions`

Expand EditMarkLabelSelectionOptions

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. */

Related types: MarkSelector.

`EditMarkSelectionOptions`

Expand EditMarkSelectionOptions

export type EditMarkSelectionOptions = {
  selection?: string;
} & MarkSelector;

Related types: MarkSelector.

`EditNormalizedDataOptions`

Expand EditNormalizedDataOptions

export type EditNormalizedDataOptions = FocusedDerivedDataEdit<NormalizedDataOptions>;

`EditOpacityScaleOptions`

Expand EditOpacityScaleOptions

export type EditOpacityScaleOptions = FocusedScaleSelection & WithoutScaleId<OpacityScaleOptions>;

`EditParallelAxisOptions`

Expand EditParallelAxisOptions

export type EditParallelAxisOptions = ParallelAxisComponentsOptions;

Related types: ParallelAxisComponentsOptions.

`EditParallelScaleOptions`

Expand EditParallelScaleOptions

export type EditParallelScaleOptions = {
  target: string;
  dimension: string;
} & WithoutScaleId<
  QuantitativePositionScaleOptions | CategoricalPositionScaleOptions
>;

`EditPolarAxisOptions`

Expand EditPolarAxisOptions

export interface EditPolarAxisOptions {
  angle?: number;
  line?: false | AxisLineStyleOptions;
  ticks?: false | PolarTickOptions;
  labels?: false | PolarLabelOptions;
  ticksAndLabels?: false | PolarTicksAndLabelsOptions;
  title?: false | PolarTitleOptions;
}

`EditPolarGridOptions`

Expand EditPolarGridOptions

export interface EditPolarGridOptions {
  count?: number;
  values?: readonly AxisValue[];
  color?: string;
  lineWidth?: number;
  strokeDash?: readonly number[];
}

Related types: AxisValue.

`EditRScaleOptions`

Expand EditRScaleOptions

export type EditRScaleOptions = FocusedScaleSelection & WithoutScaleId<RadiusScaleOptions> & {
  radialMapping?: RadialMapping;
};

`EditRadarPlotOptions`

Expand EditRadarPlotOptions

export interface EditRadarPlotOptions {
  target?: string;
  wide: { fields: readonly [string, string, ...string[]] };
}

`EditRadialAxisOptions`

Expand EditRadialAxisOptions

export interface EditRadialAxisOptions
  extends Omit<EditPolarAxisOptions, "title"> {
  title?: false | RadialTitleOptions;
}

Related types: EditPolarAxisOptions · RadialTitleOptions.

`EditRaincloudPlotOptions`

Expand EditRaincloudPlotOptions

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 | RaincloudColorChannel;
}

`EditRectMarkOptions`

Expand EditRectMarkOptions

export interface EditRectMarkOptions extends Omit<RectMarkOptions, "id" | "data"> {
  target?: string;
}

Related types: RectMarkOptions.

`EditRegressionDataOptions`

Expand EditRegressionDataOptions

export type EditRegressionDataOptions = FocusedDerivedDataEdit<RegressionDataOptions>;

`EditRegressionOptions`

Expand EditRegressionOptions

export interface EditRegressionOptions {
  placement?: "source" | "plot-last";
  target?: string;
  data?: string;
  x?: string;
  y?: string;
  groupBy?: string | false;
  method?: RegressionMethod;
  degree?: number;
  span?: number;
  robustIterations?: number;
  confidenceMethod?: ConfidenceIntervalMethod;
  level?: number;
  confidence?: number;
  interval?: RegressionInterval | false;
  missing?: "error" | "drop";
  predict?: RegressionPredictOptions | false;
  band?: false | RegressionBandOptions;
  line?: StrokeStyleDetails & { strokeWidth?: number; curve?: CurveInterpolation };
  sourceBinding?: "fixed" | "follow";
}

`EditRegressionStatisticsDataOptions`

Expand EditRegressionStatisticsDataOptions

export interface EditRegressionStatisticsDataOptions {
  target?: string;
  source?: string;
}

`EditScaleOptions`

Expand EditScaleOptions

export interface EditScaleOptions {
  radialMapping?: RadialMapping;
  id?: string;
  type?: ScaleType;
  domain?: "auto" | readonly unknown[];
  emptyDomain?: "preserve" | "require-explicit";
  range?: ScaleRange;
  nice?: boolean | LinearNiceCountOptions;
  zero?: boolean;
  clamp?: boolean;
  reverse?: boolean;
  base?: number;
  exponent?: number;
  constant?: number;
  paddingInner?: number;
  paddingOuter?: number;
  padding?: number;
  align?: number;
  palette?: Palette;
  interpolate?: ContinuousColorInterpolation;
  whitePoint?: "d65" | "d50" | "auto";
  /** Finite Cubehelix lightness gamma; auto restores 1. */
  gamma?: number | "auto";
  midpoint?: number | "auto";
  unknown?: unknown;
}

`EditSemanticOptions`

Expand EditSemanticOptions

export type EditSemanticOptions =
  | { property: string; value: unknown; remove?: false }
  | { property: string; remove: true; value?: never };

`EditShapeScaleOptions`

Expand EditShapeScaleOptions

export type EditShapeScaleOptions = FocusedScaleSelection & WithoutScaleId<ShapeScaleOptions>;

`EditSizeScaleOptions`

Expand EditSizeScaleOptions

export type EditSizeScaleOptions = FocusedScaleSelection &
  (ExistingSizeScaleEditPatch | SizeScaleTypeEditPatch);

`EditSortedDataOptions`

Expand EditSortedDataOptions

export interface EditSortedDataOptions {
  target: string;
  sortBy: readonly [SortKey, ...SortKey[]];
  dependents?: DerivedDataDependents;
}

Related types: SortKey · DerivedDataDependents.

`EditStackDataOptions`

Expand EditStackDataOptions

export type EditStackDataOptions = FocusedDerivedDataEdit<StackDataOptions>;

Related types: FocusedDerivedDataEdit · StackDataOptions.

`EditStrokeDashScaleOptions`

Expand EditStrokeDashScaleOptions

export type EditStrokeDashScaleOptions = FocusedScaleSelection &
  Omit<WithoutScaleId<DashScaleOptions>, "unknown"> & { unknown?: DashStyle | DashPattern | undefined };

`EditStrokeScaleOptions`

Expand EditStrokeScaleOptions

export type EditStrokeScaleOptions = { target: string } & WithoutScaleSelection<EditColorScaleOptions>;

Related types: WithoutScaleSelection · EditColorScaleOptions.

`EditStrokeWidthScaleOptions`

Expand EditStrokeWidthScaleOptions

export type EditStrokeWidthScaleOptions = FocusedScaleSelection & WithoutScaleId<StrokeWidthScaleOptions>;

`EditSummaryDataOptions`

Expand EditSummaryDataOptions

export type EditSummaryDataOptions = FocusedWeightedDerivedDataEdit<
  SummaryDataOptions,
  StatisticalWeight
>;

`EditTextMarkOptions`

Expand EditTextMarkOptions

export interface EditTextMarkOptions extends Omit<TextMarkOptions, "id" | "data" | "source" | "text"> {
  target?: string;
}

Related types: TextMarkOptions.

`EditThetaAxisOptions`

Expand EditThetaAxisOptions

export interface EditThetaAxisOptions
  extends Omit<EditPolarAxisOptions, "angle" | "labels" | "ticksAndLabels"> {
  labels?: false | ThetaAxisLabelOptions;
  ticksAndLabels?: false | ThetaTicksAndLabelsOptions;
}

`EditThetaScaleOptions`

Expand EditThetaScaleOptions

export type EditThetaScaleOptions = FocusedScaleSelection & WithoutScaleId<ThetaScaleOptions>;

`EditTimeUnitDataOptions`

Expand EditTimeUnitDataOptions

export type EditTimeUnitDataOptions = FocusedDerivedDataEdit<TimeUnitDataOptions>;

Related types: FocusedDerivedDataEdit · TimeUnitDataOptions.

`EditTitleOptions`

Expand EditTitleOptions

export interface EditTitleOptions
  extends Omit<TitleOptions, "text" | "subtitle"> {
  text?: string;
  subtitle?: string | false;
}

Related types: TitleOptions.

`EditViolinPlotOptions`

Expand EditViolinPlotOptions

export interface EditViolinPlotOptions {
  target?: string;
  data?: string;
  x?: ViolinPlotPositionChannel;
  y?: ViolinPlotPositionChannel;
  split?: false | ViolinPlotSplitOptions;
  density?: Omit<ViolinPlotDensityOptions, "weight"> & {
    weight?: StatisticalWeight | false;
  };
}

`EditWindowDataOptions`

Expand EditWindowDataOptions

export type EditWindowDataOptions = FocusedDerivedDataEdit<WindowDataOptions>;

Related types: FocusedDerivedDataEdit · WindowDataOptions.

`EditXOffsetScaleOptions`

Expand EditXOffsetScaleOptions

export type EditXOffsetScaleOptions = { target: string } & OffsetScaleEditPatch;

Related types: OffsetScaleEditPatch.

`EditXScaleOptions`

Expand EditXScaleOptions

export type EditXScaleOptions = FocusedScaleSelection & WithoutScaleId<
  QuantitativePositionScaleOptions | TemporalPositionScaleOptions | CategoricalPositionScaleOptions
>;

`EditYOffsetScaleOptions`

Expand EditYOffsetScaleOptions

export type EditYOffsetScaleOptions = EditXOffsetScaleOptions;

Related types: EditXOffsetScaleOptions.

`EditYScaleOptions`

Expand EditYScaleOptions

export type EditYScaleOptions = EditXScaleOptions;

Related types: EditXScaleOptions.

`EncodeChannelsOptions`

Expand EncodeChannelsOptions

export interface EncodeChannelsOptions {
  target: string;
  channels: AtLeastOne<EncodingChannelAssignments>;
}

Related types: AtLeastOne · EncodingChannelAssignments.

`EncodingChannelAssignments`

Expand EncodingChannelAssignments

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>;
  dx?: WithoutEncodingTarget<TextOffsetEncodingOptions>;
  dy?: WithoutEncodingTarget<TextOffsetEncodingOptions>;
}

`EndpointCategoryChannel`

Expand EndpointCategoryChannel

export type EndpointCategoryChannel = string | {
  field: string;
  fieldType?: "nominal" | "ordinal";
  scale?: NonPointCategoricalPositionScaleOptions;
};

`EndpointLabelOptions`

Expand EndpointLabelOptions

export type EndpointLabelOptions = Omit<
  TextMarkOptions,
  "id" | "data" | "source" | "text"
> & {
  format?: TextFormat;
  layout?: false | Omit<LabelLayoutOptions, "target">;
} & (
  | { field?: string; value?: never }
  | { field?: never; value: unknown }
);

Related types: TextMarkOptions · TextFormat · LabelLayoutOptions.

`EndpointPlotBaseOptions`

Expand EndpointPlotBaseOptions

type EndpointPlotBaseOptions = {
  id?: string;
  data?: string;
  coordinate?: string;
  category: EndpointCategoryChannel;
  orientation?: "horizontal" | "vertical";
  summary?: EndpointPlotSummary;
  guides?: false | CartesianSeparateGuideOptions;
};

`EndpointPlotSummary`

Expand EndpointPlotSummary

export type EndpointPlotSummary = false | "mean" | "median" | "sum" | "min" | "max";

`EndpointValueChannel`

Expand EndpointValueChannel

export type EndpointValueChannel = string | {
  field: string;
  fieldType?: "quantitative";
  scale?: NonPointQuantitativePositionScaleOptions;
};

`ErrorBandExplicitIntervalChannel`

Expand ErrorBandExplicitIntervalChannel

export interface ErrorBandExplicitIntervalChannel {
  center: string;
  lower: string;
  upper: string;
  scale?: NonPointQuantitativePositionScaleOptions;
}

`ErrorBandIntervalChannel`

Expand ErrorBandIntervalChannel

export type ErrorBandIntervalChannel =
  | ErrorBandStatisticalIntervalChannel
  | ErrorBandExplicitIntervalChannel;

`ErrorBandOptions`

Expand ErrorBandOptions

export interface ErrorBandOptions extends StrokeStyleDetails {
  id?: string;
  target?: string;
  data?: string;
  x?: ErrorBandPositionChannel | ErrorBandIntervalChannel;
  y?: ErrorBandPositionChannel | ErrorBandIntervalChannel;
  groupBy?: string;
  coordinate?: string;
  fill?: FillPaint;
  opacity?: number;
  curve?: CurveInterpolation;
  boundaries?: false | (StrokeStyleDetails & {
    stroke?: string;
    strokeWidth?: number;
    strokeDash?: DashStyle | DashPattern;
    opacity?: number;
    curve?: CurveInterpolation;
  });
}

`ErrorBandPositionChannel`

Expand ErrorBandPositionChannel

export type ErrorBandPositionChannel = { field?: string } & (
  | {
      fieldType?: "quantitative";
      scale?: NonPointQuantitativePositionScaleOptions;
    }
  | {
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      scale?: NonPointTemporalPositionScaleOptions;
    }
);

`ErrorBandStatisticalIntervalChannel`

Expand ErrorBandStatisticalIntervalChannel

export interface ErrorBandStatisticalIntervalChannel {
  field?: string;
  center?: IntervalCenter;
  extent?: IntervalExtent;
  method?: ConfidenceIntervalMethod;
  level?: number;
  scale?: NonPointQuantitativePositionScaleOptions;
}

`ErrorBarExplicitIntervalChannel`

Expand ErrorBarExplicitIntervalChannel

export interface ErrorBarExplicitIntervalChannel {
  center: string;
  lower: string;
  upper: string;
  scale?: NonPointQuantitativePositionScaleOptions;
}

`ErrorBarIntervalChannel`

Expand ErrorBarIntervalChannel

export type ErrorBarIntervalChannel =
  | ErrorBarStatisticalIntervalChannel
  | ErrorBarExplicitIntervalChannel;

`ErrorBarOffsetChannel`

Expand ErrorBarOffsetChannel

export interface ErrorBarOffsetChannel {
  field?: string;
  fieldType?: "nominal" | "ordinal";
  scale?: OffsetScaleOptions;
  paddingInner?: number;
  paddingOuter?: number;
}

Related types: OffsetScaleOptions.

`ErrorBarOptions`

Expand ErrorBarOptions

export interface ErrorBarOptions extends StrokeStyleDetails {
  id?: string;
  target?: string;
  data?: string;
  x?: ErrorBarPositionChannel | ErrorBarIntervalChannel;
  y?: ErrorBarPositionChannel | ErrorBarIntervalChannel;
  xOffset?: ErrorBarOffsetChannel;
  yOffset?: ErrorBarOffsetChannel;
  groupBy?: string | false;
  coordinate?: string;
  caps?: boolean;
  capSize?: number;
  stroke?: string;
  strokeWidth?: number;
  strokeDash?: DashStyle | DashPattern;
  opacity?: number;
}

`ErrorBarPositionChannel`

Expand ErrorBarPositionChannel

export type ErrorBarPositionChannel = { field?: string } & (
  | {
      fieldType?: "nominal" | "ordinal";
      scale?: NonPointCategoricalPositionScaleOptions;
    }
  | {
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      scale?: NonPointTemporalPositionScaleOptions;
    }
  | {
      fieldType: "quantitative";
      scale?: NonPointQuantitativePositionScaleOptions;
    }
);

`ErrorBarStatisticalIntervalChannel`

Expand ErrorBarStatisticalIntervalChannel

export interface ErrorBarStatisticalIntervalChannel {
  field?: string;
  center?: IntervalCenter;
  extent?: IntervalExtent;
  method?: ConfidenceIntervalMethod;
  level?: number;
  scale?: NonPointQuantitativePositionScaleOptions;
}

`ExistingSizeScaleEditPatch`

Expand ExistingSizeScaleEditPatch

type ExistingSizeScaleEditPatch = {
  type?: never;
  domain?: "auto" | readonly [string | number | boolean, ...(string | number | boolean)[]];
  range?: "auto" | readonly [number, ...number[]];
  unknown?: number;
  clamp?: boolean;
  reverse?: boolean;
  base?: number;
  exponent?: number;
};

`FacadePositionChannel`

Expand FacadePositionChannel

type FacadePositionChannel<Quantitative, Temporal, Categorical> =
  | string
  | (Omit<PositionEncodingBase, "target" | "coordinate"> &
      PositionScaleBranches<Quantitative, Temporal, Categorical>);

Related types: PositionEncodingBase · PositionScaleBranches.

`FacetGap`

Expand FacetGap

export type FacetGap = number | Readonly<{ x: number; y: number }>;

`FacetGridOptions`

Expand FacetGridOptions

export interface FacetGridOptions {
  id?: string;
  data?: string;
  rows: FacetGridRole;
  columns: FacetGridRole;
  combinations?: "observed" | "full";
  gap?: FacetGap;
  align?: CompositionAlign;
  padding?: number | CompositionPadding;
  scales?: FacetScaleResolutions;
  guides?: FacetGuideOptions;
  headers?: FacetHeadersOptions;
  /** Interpret gap between child canvases (default), inner plots, or retained full content (wrapped facets). */
  spacing?: "canvas" | "plot";
  /** Share the existing top margin rather than adding title/header reservations. Requires plot spacing. */
  topLane?: FacetTopLaneMode;
}

`FacetGridRole`

Expand FacetGridRole

export interface FacetGridRole {
  field: string;
  values?: readonly DatasetScalar[];
}

Related types: DatasetScalar.

`FacetGuideOptions`

Expand FacetGuideOptions

export interface FacetGuideOptions {
  axes?: "each" | "outer" | { x?: "each" | "outer"; y?: "each" | "outer" };
  legend?: false | "shared" | LegendOptions;
}

Related types: LegendOptions.

`FacetHeaderAlign`

Expand FacetHeaderAlign

export type FacetHeaderAlign = "start" | "center" | "end";

`FacetHeaderRole`

Expand FacetHeaderRole

export type FacetHeaderRole = "all" | "row" | "column";

`FacetHeaderSide`

Expand FacetHeaderSide

export type FacetHeaderSide = "top" | "bottom" | "left" | "right";

`FacetHeaderTitleOptions`

Expand FacetHeaderTitleOptions

export interface FacetHeaderTitleOptions {
  /** Required when introducing a title; edits preserve the existing text. One line. */
  text?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
  color?: string;
  offset?: number;
  align?: FacetHeaderAlign;
  rotation?: RotationInput;
  alongOffset?: number;
}

Related types: FacetHeaderAlign · RotationInput.

`FacetHeadersOptions`

Expand FacetHeadersOptions

export type FacetHeadersOptions = Omit<EditFacetHeadersOptions, "role" | "side" | "title"> & {
  row?: Omit<EditFacetHeadersOptions, "role">;
  column?: Omit<EditFacetHeadersOptions, "role">;
};

Related types: EditFacetHeadersOptions.

`FacetOptions`

Expand FacetOptions

export interface FacetOptions {
  id?: string;
  field: string;
  /** Common row-preserving ancestor, or an explicit materialized fold ancestor of every layer. */
  data?: string;
  values?: readonly DatasetScalar[];
  columns?: number;
  gap?: FacetGap;
  align?: CompositionAlign;
  padding?: number | CompositionPadding;
  scales?: FacetScaleResolutions;
  guides?: FacetGuideOptions;
  headers?: FacetHeadersOptions;
  /** Interpret gap between child canvases (default), inner plots, or retained full content (wrapped facets). */
  spacing?: "canvas" | "plot" | "content";
  /** Share the existing top margin rather than adding title/header reservations. Requires plot spacing. */
  topLane?: FacetTopLaneMode;
}

`FacetScaleResolution`

Expand FacetScaleResolution

export type FacetScaleResolution = "shared" | "independent";

`FacetScaleResolutions`

Expand FacetScaleResolutions

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;
}

Related types: FacetScaleResolution.

`FacetTopLaneMode`

Expand FacetTopLaneMode

export type FacetTopLaneMode = "stacked" | "shared";

`FieldType`

Expand FieldType

export type FieldType = "quantitative" | "temporal" | "ordinal" | "nominal";

`FillPaint`

Expand FillPaint

export type FillPaint = string | LinearGradientPaint;

Related types: LinearGradientPaint.

`FilledLegendSymbolRecipe`

Expand FilledLegendSymbolRecipe

type FilledLegendSymbolRecipe = "auto"
  | { width?: number; height?: number; stroke?: string; strokeWidth?: number }
  | { layers: readonly LegendSymbolLayer[] };

Related types: LegendSymbolLayer.

`FilledMarkLegendOptions`

Expand FilledMarkLegendOptions

type FilledMarkLegendOptions = Omit<LegendOptions, "symbol" | "representation" | "combine"> & (
  | { combine?: "separate" | "size-shape"; representation?: "gradient"; symbol?: FilledLegendSymbolRecipe }
  | { combine?: "separate" | "size-shape"; representation: "symbols"; symbol?: "auto" | { type?: "point"; radius?: number; stroke?: string; strokeWidth?: number } }
  | { combine: "color-size"; representation?: never; symbol?: "auto" | { type?: "point"; stroke?: string; strokeWidth?: number; opacity?: number } }
);

Related types: LegendOptions · FilledLegendSymbolRecipe.

`FilledMarkStroke`

Expand FilledMarkStroke

type FilledMarkStroke = string | false;

`FilterBound`

Expand FilterBound

type FilterBound = number | string;

`FilterComparison`

Expand FilterComparison

export type FilterComparison =
  | { op: "eq" | "neq"; value: unknown }
  | { op: "lt" | "lte" | "gt" | "gte"; value: number | string };

`FilterDataOptions`

Expand FilterDataOptions

export type FilterDataOptions = {
  id: string;
  source?: string;
  field: string;
  nulls?: "include" | "exclude";
} & FilterModeOptions;

Related types: FilterModeOptions.

`FilterMarksOptions`

Expand FilterMarksOptions

export type FilterMarksOptions = {
  target?: string;
  mode?: "replace" | "compose";
} & MarkSelector;

Related types: MarkSelector.

`FilterModeOptions`

Expand FilterModeOptions

export type FilterModeOptions =
  | { oneOf: readonly [DatasetScalar, ...DatasetScalar[]]; noneOf?: never; predicate?: never; range?: never }
  | { oneOf?: never; noneOf: readonly [DatasetScalar, ...DatasetScalar[]]; predicate?: never; range?: never }
  | { oneOf?: never; noneOf?: never; predicate: FilterComparison; range?: never }
  | { oneOf?: never; noneOf?: never; predicate?: never; range: FilterRange };

Related types: DatasetScalar · FilterComparison · FilterRange.

`FilterModePatch`

Expand FilterModePatch

type FilterModePatch =
  | { oneOf: readonly [DatasetScalar, ...DatasetScalar[]]; noneOf?: never; predicate?: never; range?: never }
  | { oneOf?: never; noneOf: readonly [DatasetScalar, ...DatasetScalar[]]; predicate?: never; range?: never }
  | { oneOf?: never; noneOf?: never; predicate: FilterComparison; range?: never }
  | { oneOf?: never; noneOf?: never; predicate?: never; range: FilterRangePatch }
  | { oneOf?: never; noneOf?: never; predicate?: never; range?: never };

Related types: DatasetScalar · FilterComparison · FilterRangePatch.

`FilterRange`

Expand FilterRange

export type FilterRange = FilterRangeBounds & FilterRangeClosure;

Related types: FilterRangeBounds · FilterRangeClosure.

`FilterRangeBounds`

Expand FilterRangeBounds

type FilterRangeBounds =
  | { min: FilterBound; max?: FilterBound }
  | { min?: FilterBound; max: FilterBound };

Related types: FilterBound.

`FilterRangeClosure`

Expand FilterRangeClosure

type FilterRangeClosure =
  | { inclusive?: boolean; minInclusive?: never; maxInclusive?: never }
  | { inclusive?: never; minInclusive?: boolean; maxInclusive?: boolean };

`FilterRangePatch`

Expand FilterRangePatch

export type FilterRangePatch = FilterRangeClosure & {
  min?: FilterBound | false;
  max?: FilterBound | false;
};

Related types: FilterRangeClosure · FilterBound.

`FitCanvasOptions`

Expand FitCanvasOptions

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";
}

`FlattenDataOptions`

Expand FlattenDataOptions

export interface FlattenDataOptions {
  id: string;
  source?: string;
  fields: readonly string[];
  as?: readonly string[];
}

`FocusedDerivedDataEdit`

Expand FocusedDerivedDataEdit

type FocusedDerivedDataEdit<T> = {
  target: string;
  dependents?: DerivedDataDependents;
} & FocusedDerivedDataPatch<T>;

`FocusedDerivedDataPatch`

Expand FocusedDerivedDataPatch

type FocusedDerivedDataPatch<T> = T extends unknown
  ? Partial<Omit<T, "id" | "source">>
  : never;

`FocusedScaleSelection`

Expand FocusedScaleSelection

type FocusedScaleSelection = { id?: string; target?: string };

`FocusedWeightedDerivedDataEdit`

Expand FocusedWeightedDerivedDataEdit

type FocusedWeightedDerivedDataEdit<T, Weight> = {
  target: string;
  dependents?: DerivedDataDependents;
} & (T extends unknown
  ? Omit<FocusedDerivedDataPatch<T>, "weight"> & { weight?: Weight | false }
  : never);

`FoldDataOptions`

Expand FoldDataOptions

export interface FoldDataOptions {
  id: string;
  source?: string;
  fields: readonly string[];
  as?: FoldDataOutputFields;
}

Related types: FoldDataOutputFields.

`FoldDataOutputFields`

Expand FoldDataOutputFields

export interface FoldDataOutputFields {
  key?: string;
  value?: string;
}

`GradientPlotAppearanceOptions`

Expand GradientPlotAppearanceOptions

export interface GradientPlotAppearanceOptions {
  palette?: Palette;
  opacity?: readonly [number, number];
}

Related types: Palette.

`GradientPlotCenterOptions`

Expand GradientPlotCenterOptions

export interface GradientPlotCenterOptions extends StrokeStyleDetails {
  type?: "mean" | "median";
  stroke?: string;
  strokeWidth?: number;
}

Related types: StrokeStyleDetails.

`GradientPlotDensityLegendOptions`

Expand GradientPlotDensityLegendOptions

type GradientPlotDensityLegendOptions = {
  title?: string;
  position?: "right";
};

`GradientPlotDensityOptions`

Expand GradientPlotDensityOptions

export interface GradientPlotDensityOptions {
  bandwidth?: "auto" | number;
  extent?: "auto" | readonly [number, number];
  steps?: number;
  kernel?: DensityKernel;
  normalization?: DensityNormalization;
}

Related types: DensityKernel · DensityNormalization.

`GradientPlotGuideOptions`

Expand GradientPlotGuideOptions

type GradientPlotGuideOptions = Omit<CartesianGuideOptions, "legend"> & {
  legend?: false | GradientPlotDensityLegendOptions;
};

`GradientPlotOptions`

Expand GradientPlotOptions

export interface GradientPlotOptions {
  id?: string;
  target?: string;
  data?: string;
  x?: GradientPlotPositionChannel;
  y?: GradientPlotPositionChannel;
  coordinate?: string;
  color?: BasicColorChannel | { value: string };
  density?: GradientPlotDensityOptions;
  width?: { band?: number };
  gradient?: GradientPlotAppearanceOptions;
  center?: false | GradientPlotCenterOptions;
  guides?: false | GradientPlotGuideOptions;
}

`GradientPlotPositionChannel`

Expand GradientPlotPositionChannel

export type GradientPlotPositionChannel = BoxPlotPositionChannel;

Related types: BoxPlotPositionChannel.

`GraphicType`

Expand GraphicType

export type GraphicType =
  | "canvas"
  | "collection"
  | "circle"
  | "rect"
  | "line"
  | "text"
  | "path";

`GridDirectionOptions`

Expand GridDirectionOptions

export interface GridDirectionOptions {
  strokeDashMap?: CartesianGuideDashMap | "auto";
  /** Signed logical pixels along the scale: vertical lines right, horizontal lines down. */
  alongOffset?: number;
  /** Grid draw order relative to marks at zero: positive above, nonpositive behind. */
  zIndex?: number;
  /** Band centers by default; boundary draws both edges of each selected band. */
  bandPosition?: "center" | "boundary";
  scale?: string;
  coordinate?: string;
  count?: number;
  values?: readonly CategoryValue[];
  color?: string;
  lineWidth?: number;
  strokeDash?: readonly number[];
}

Related types: CartesianGuideDashMap · CategoryValue.

`GroupEncodingOptions`

Expand GroupEncodingOptions

export type GroupEncodingOptions = { target?: string; fieldType?: "nominal" } & (
  | { field: string; fields?: never }
  | { fields: readonly [string, ...string[]]; field?: never }
);

`HeatmapBaseOptions`

Expand HeatmapBaseOptions

export interface HeatmapBaseOptions {
  id?: string;
  data?: string;
  coordinate?: string;
  rect?: RectStyleDetails & {
    clip?: boolean;
    opacity?: number;
    stroke?: string | false;
    strokeWidth?: number;
  };
  guides?: false | CartesianSeparateGuideOptions;
}

`HeatmapBinOptions`

Expand HeatmapBinOptions

export interface HeatmapBinOptions {
  bins?: number | Bin2DCounts;
  extent?: Bin2DExtent;
  assignment?: "edges" | "step";
  includeEmpty?: boolean;
}

Related types: Bin2DCounts · Bin2DExtent.

`HeatmapCategoryPositionChannel`

Expand HeatmapCategoryPositionChannel

export type HeatmapCategoryPositionChannel =
  | string
  | {
      field: string;
      fieldType?: "nominal" | "ordinal";
      scale?: NonPointBandPositionScaleOptions;
    };

Related types: NonPointBandPositionScaleOptions.

`HighlightMarksOptions`

Expand HighlightMarksOptions

export interface HighlightMarksOptions {
  id?: string;
  target?: string;
  select?: MarkSelector;
  selection?: string;
  color?: string;
  opacity?: number;
  fill?: string;
  stroke?: string;
  strokeWidth?: number;
  strokeDash?: DashStyle | DashPattern;
  shape?: PointShape;
  size?: number;
  offset?: { x?: number; y?: number };
  dimOthers?: boolean | { opacity?: number };
  bringToFront?: boolean;
}

Related types: MarkSelector · DashStyle · DashPattern · PointShape.

`HistogramCategoricalColorChannel`

Expand HistogramCategoricalColorChannel

type HistogramCategoricalColorChannel =
  | string
  | {
      field: string;
      fieldType?: "nominal" | "ordinal";
      scale?: NonPointCategoricalColorScaleOptions;
      palette?: Palette;
      layout?: Exclude<ColorLayout, "center">;
    };

`HistogramEncodingOptions`

Expand HistogramEncodingOptions

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 }
  | {
      maxBins?: never;
      binStep?: never;
      binBoundaries: readonly [number, number, ...number[]];
    }
);

`HorizonEncodingOptions`

Expand HorizonEncodingOptions

export interface HorizonEncodingOptions {
  target?: string;
  source?: 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;
}

`HorizonMissingPolicy`

Expand HorizonMissingPolicy

export type HorizonMissingPolicy = "break" | "error";

`HorizonOutputFields`

Expand HorizonOutputFields

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;
}

`HorizonOverflowPolicy`

Expand HorizonOverflowPolicy

export type HorizonOverflowPolicy = "clip" | "error";

`HorizonPaletteOptions`

Expand HorizonPaletteOptions

export interface HorizonPaletteOptions {
  positive?: Palette;
  negative?: Palette;
}

Related types: Palette.

`HorizonPlotGuideOptions`

Expand HorizonPlotGuideOptions

export type HorizonPlotGuideOptions = {
  axes?: false | (Omit<CAxes, "y"> & { y?: false });
  grid?: false | { vertical?: boolean | ContinuousGridDirectionOptions; horizontal?: false };
  legend?: false;
};

Related types: CAxes · ContinuousGridDirectionOptions.

`HorizonResolution`

Expand HorizonResolution

export type HorizonResolution = "shared" | "independent";

`HorizonXEncoding`

Expand HorizonXEncoding

export type HorizonXEncoding = { field: string } & (
  | {
      fieldType: "quantitative";
      scale?: NonPointQuantitativePositionScaleOptions;
    }
  | {
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      scale?: NonPointTemporalPositionScaleOptions;
    }
  | {
      fieldType?: undefined;
      scale?:
        | NonPointQuantitativePositionScaleOptions
        | NonPointTemporalPositionScaleOptions;
    }
);

`HorizonYEncoding`

Expand HorizonYEncoding

export interface HorizonYEncoding {
  field: string;
  fieldType?: "quantitative";
  scale?: HorizonYScaleOptions;
}

Related types: HorizonYScaleOptions.

`HorizonYScaleOptions`

Expand HorizonYScaleOptions

export type HorizonYScaleOptions = ScaleFields<"id" | "clamp" | "reverse"> & {
  type?: "linear";
  domain?: readonly [0, 1];
  range?: "auto" | readonly [number, number];
};

Related types: ScaleFields.

`ImputedDataBaseOptions`

Expand ImputedDataBaseOptions

type ImputedDataBaseOptions = {
  id: string;
  source?: string;
  fields: string | readonly [string, ...string[]];
  groupBy?: string | readonly string[];
  edges?: "keep" | "error";
  maxGap?: number;
};

`ImputedDataOptions`

Expand ImputedDataOptions

export type ImputedDataOptions = ImputedDataBaseOptions & (
  | { method?: "mean"; value?: never; sortBy?: readonly WindowSort[]; }
  | {
      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" }];
    }
);

Related types: ImputedDataBaseOptions · WindowSort · DatasetScalar.

`InferredRuleDatumPositionEncodingOptions`

Expand InferredRuleDatumPositionEncodingOptions

type InferredRuleDatumPositionEncodingOptions = {
  field?: never;
  datum: unknown;
  target?: string;
  coordinate?: string;
  fieldType?: undefined;
  scale?:
    | NonPointQuantitativePositionScaleOptions
    | NonPointCategoricalPositionScaleOptions;
};

`InsertCompositionChildOptions`

Expand InsertCompositionChildOptions

export interface InsertCompositionChildOptions {
  id: string;
  program: ChartProgram;
  before?: string;
  after?: string;
}

`IntervalCenter`

Expand IntervalCenter

export type IntervalCenter = "mean" | "median";

`IntervalDataOptions`

Expand IntervalDataOptions

export interface IntervalDataOptions {
  id: string;
  source?: string;
  field: string;
  groupBy?: string | readonly string[];
  center?: IntervalCenter;
  extent?: IntervalExtent;
  method?: MeanConfidenceIntervalMethod;
  level?: number;
  missing?: "error" | "drop";
  as?: IntervalOutputFields;
}

`IntervalExtent`

Expand IntervalExtent

export type IntervalExtent = "stderr" | "stdev" | "ci" | "iqr";

`IntervalOutputFields`

Expand IntervalOutputFields

export interface IntervalOutputFields {
  center: string;
  lower: string;
  upper: string;
}

`IntervalPlotBaseOptions`

Expand IntervalPlotBaseOptions

type IntervalPlotBaseOptions = {
  id?: string;
  data?: string;
  coordinate?: string;
  xOffset?: ErrorBarOffsetChannel;
  yOffset?: ErrorBarOffsetChannel;
  groupBy?: string | false;
  color?: BasicColorChannel;
  point?: CreateScatterPlotOptions["point"];
  errorBar?: IntervalPlotErrorBarOptions;
  guides?: false | CartesianSeparateGuideOptions;
};

`IntervalPlotErrorBarOptions`

Expand IntervalPlotErrorBarOptions

export interface IntervalPlotErrorBarOptions extends StrokeStyleDetails {
  caps?: boolean;
  capSize?: number;
  stroke?: string;
  strokeWidth?: number;
  strokeDash?: DashStyle | DashPattern;
  opacity?: number;
}

Related types: StrokeStyleDetails · DashStyle · DashPattern.

`JitterMaxOffset`

Expand JitterMaxOffset

export type JitterMaxOffset =
  | { pixels: number; band?: never }
  | { pixels?: never; band: number };

`JitterPointsOptions`

Expand JitterPointsOptions

export interface JitterPointsOptions {
  target?: string;
  channel: "x" | "y" | "both";
  maxOffset: JitterMaxOffset;
  seed?: string | number;
  key?: string;
}

Related types: JitterMaxOffset.

`LabelLayoutAxis`

Expand LabelLayoutAxis

export type LabelLayoutAxis = "x" | "y" | "both";

`LabelLayoutBounds`

Expand LabelLayoutBounds

export type LabelLayoutBounds = "plot" | "canvas";

`LabelLayoutOptions`

Expand LabelLayoutOptions

export interface LabelLayoutOptions {
  target?: string;
  axis?: LabelLayoutAxis;
  padding?: number;
  maxDisplacement?: number;
  bounds?: LabelLayoutBounds;
  leader?: false | LabelLeaderOptions;
}

`LabelLeaderOptions`

Expand LabelLeaderOptions

export interface LabelLeaderOptions {
  stroke?: string;
  strokeWidth?: number;
  strokeDash?: readonly number[];
  opacity?: number;
}

`LegendBlockSymbolPatch`

Expand LegendBlockSymbolPatch

export interface LegendBlockSymbolPatch {
  /** Point glyph area in square pixels. */
  size?: number;
  fill?: string;
  stroke?: string;
  strokeWidth?: number;
  opacity?: number;
}

`LegendBlockTextPatch`

Expand LegendBlockTextPatch

export interface LegendBlockTextPatch {
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
  color?: string;
}

`LegendBorderOptions`

Expand LegendBorderOptions

export interface LegendBorderOptions {
  /** Even-length non-negative finite dash sequence; [] restores a solid frame. */
  strokeDash?: readonly number[];
  color?: string;
  lineWidth?: number;
  padding?: number;
  background?: string;
}

`LegendChannel`

Expand LegendChannel

export type LegendChannel = NonNullable<LegendOptions["channels"]>[number];

Related types: LegendOptions.

`LegendOptions`

Expand LegendOptions

export interface LegendOptions {
  /** Positive sample window height. Clips point-bearing glyphs without changing mapped area. */
  clipHeight?: number;
  /** Explicitly combine ordinal size/shape or same-field quantitative color/size circle samples. Omission retains separate blocks. */
  combine?: "separate" | "size-shape" | "color-size";
  /** Continuous color only. Omission creates the existing gradient; symbols samples the same scale without changing marks. */
  representation?: "gradient" | "symbols";
  /** Categorical, interval, size, or stroke-width layout. Defaults to edge; legacy-bottom is categorical and requires bottom position. */
  layout?: "edge" | "legacy-bottom";
  /** Categorical and ordinal-size display limit; omitted or false shows every item. */
  overflow?: false | { maxItems: number; summary?: "ellipsis-count" };
  /** Categorical item order; preserves the appearance scale's assignments. */
  order?: LegendOrder;
  target?: string;
  /** 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")[];
  /** Outside right/left: complete legend stack top aligns with the plot top, including borders and excluding chart titles. */
  position?: "right" | "left" | "bottom" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
  /** Arrange every legend block owned by the selected target. Item direction and columns remain independent. */
  blockLayout?: "row" | "column" | "wrap";
  /** Occupied group top-left relative to the plot. Cannot be supplied with position, align, or offset in the same call. */
  at?: { x: number; y: number };
  /** Single top/bottom edge: align complete occupied bounds, including border strokes, to the plot. Side positions require center. */
  align?: "left" | "center" | "right";
  /** Gradient orientation is independent of position; auto is gradient-only. Categorical sides require vertical. */
  direction?: "horizontal" | "vertical";
  /** Categorical legends accept a positive column count on every supported position. */
  columns?: number;
  /** Single top/bottom edge: gap from the plot to the nearest occupied legend edge. */
  offset?: number;
  /** bottom is gradient-only; left retains the existing categorical/opacity rules. */
  titlePosition?: "top" | "left" | "bottom";
  /** false hides the title while retaining its inferred field text. */
  /** LF, CRLF and CR preserve explicit title lines, including blank lines. */
  title?: string | false;
  /** Exact ascending samples for continuous size, opacity, stroke-width, color symbols, or color/stroke gradient ticks. Cannot be combined with count. */
  values?: readonly number[];
  count?: number;
  /** Body-only opacity defaults to 1; edits preserve omitted fields. */
  gradient?: { length?: number; thickness?: number; opacity?: number };
  symbol?: LegendSymbolRecipe;
  labels?: LegendTextOptions;
  /** New categorical+size blocks share typography on every edge; retained standalone size styles remain independent. */
  titleStyle?: LegendTitleStyleOptions;
  /** Vertical items default to 18 logical pixels; the pitch grows to fit samples and labels. */
  itemGap?: number;
  /** Non-negative gap between occupied item rows; overrides vertical itemGap pitch. Item legends in edge layout only. */
  rowPadding?: number;
  /** Non-negative gap between visible title and body bounds; legacy-bottom is excluded. */
  titlePadding?: number;
  border?: boolean | LegendBorderOptions;
}

`LegendOrder`

Expand LegendOrder

export type LegendOrder = LegendValueOrder |
  { channel: "x" | "y" | "theta"; values?: never };

Related types: LegendValueOrder.

`LegendSymbolLayer`

Expand LegendSymbolLayer

export type LegendSymbolLayer =
  | { type: "line"; length?: number; lineWidth?: number; opacity?: number }
  | {
      type: "point";
      shape?: "circle";
      size?: number;
      fill?: string;
      stroke?: string;
      strokeWidth?: number;
      opacity?: number;
    }
  | {
      type: "swatch";
      width?: number;
      height?: number;
      stroke?: string;
      strokeWidth?: number;
      opacity?: number;
    };

`LegendSymbolRecipe`

Expand LegendSymbolRecipe

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; opacity?: number }
  | { length?: number; lineWidth?: number }
  | { width?: number; height?: number; stroke?: string; strokeWidth?: number }
  | { layers: readonly LegendSymbolLayer[] };

Related types: LegendSymbolLayer.

`LegendTextOptions`

Expand LegendTextOptions

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;
}

Related types: ValueFormat.

`LegendTitleStyleEditOptions`

Expand LegendTitleStyleEditOptions

export interface LegendTitleStyleEditOptions extends Omit<LegendTitleStyleOptions, "align"> {
  align?: "left" | "center" | "right" | "auto";
}

Related types: LegendTitleStyleOptions.

`LegendTitleStyleOptions`

Expand LegendTitleStyleOptions

export interface LegendTitleStyleOptions {
  /** Align a top title inside its measured content block; omission keeps native layout defaults. */
  align?: "left" | "center" | "right";
  color?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
}

`LegendValueOrder`

Expand LegendValueOrder

type LegendValueOrder = "scale" | { values: readonly CategoryValue[]; channel?: never };

Related types: CategoryValue.

`LineCategoricalColorChannel`

Expand LineCategoricalColorChannel

type LineCategoricalColorChannel<Scale = NonPointCategoricalColorScaleOptions> =
  | string
  | {
      field: string;
      fieldType?: "nominal" | "ordinal";
      scale?: Scale;
      palette?: Palette;
    };

`LineXPositionChannel`

Expand LineXPositionChannel

type LineXPositionChannel =
  | string
  | ({ field: string; bin?: PositionEncodingBase["bin"] } & (
      | {
          fieldType?: "quantitative";
          scale?: NonPointQuantitativePositionScaleOptions;
        }
      | {
          fieldType: "temporal";
          temporalUnit?: TemporalInputUnit;
          scale?: NonPointTemporalPositionScaleOptions;
        }
      | {
          fieldType: "nominal" | "ordinal";
          bin?: never;
          scale?: NonPointCategoricalPositionScaleOptions;
        }
    ));

`LineYPositionChannel`

Expand LineYPositionChannel

type LineYPositionChannel =
  | string
  | ({ field: string } & (
      | {
          fieldType?: "quantitative";
          aggregate?: AggregateOperation;
          scale?: NonPointQuantitativePositionScaleOptions;
        }
      | {
          fieldType: "temporal";
          temporalUnit?: TemporalInputUnit;
          aggregate?: never;
          scale?: NonPointTemporalPositionScaleOptions;
        }
    ));

`LinearGradientPaint`

Expand LinearGradientPaint

export interface LinearGradientPaint {
  readonly type: "linear-gradient";
  readonly from: LinearGradientPoint;
  readonly to: LinearGradientPoint;
  readonly stops: readonly [
    LinearGradientStop,
    LinearGradientStop,
    ...LinearGradientStop[]
  ];
}

Related types: LinearGradientPoint · LinearGradientStop.

`LinearGradientPoint`

Expand LinearGradientPoint

export interface LinearGradientPoint {
  readonly x: number;
  readonly y: number;
}

`LinearGradientStop`

Expand LinearGradientStop

export interface LinearGradientStop {
  readonly offset: number;
  readonly color: string;
}

`LinearNiceCountOptions`

Expand LinearNiceCountOptions

export interface LinearNiceCountOptions {
  readonly count: number;
}

`LookupDataOptions`

Expand LookupDataOptions

export interface LookupDataOptions {
  id: string;
  source?: string;
  field: string;
  lookup: { data: string; key: string; fields: readonly string[]; as?: readonly string[] };
}

`MarkGraphicProperty`

Expand MarkGraphicProperty

export type MarkGraphicProperty =
  | "x" | "y" | "width" | "height" | "radius"
  | "x1" | "y1" | "x2" | "y2"
  | "fill" | "stroke" | "strokeWidth" | "opacity";

`MarkLabelAnchor`

Expand MarkLabelAnchor

export type MarkLabelAnchor =
  | "center"
  | "insideStart"
  | "insideEnd"
  | "outsideStart"
  | "outsideEnd";

`MarkLabelPlacement`

Expand MarkLabelPlacement

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;
}

`MarkLabelPlacementLeaderOptions`

Expand MarkLabelPlacementLeaderOptions

export interface MarkLabelPlacementLeaderOptions {
  stroke?: string;
  strokeWidth?: number;
}

`MarkLabelSelectionOptions`

Expand MarkLabelSelectionOptions

export type MarkLabelSelectionOptions =
  | { select?: never; selection?: never }
  | { select: MarkSelector; selection?: never }
  | { selection: string; select?: never };

Related types: MarkSelector.

`MarkSelector`

Expand MarkSelector

export type MarkSelector = {
  grain?: "item" | "stack";
} & (
  | { field: string; channel?: 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 }
  | { op: "oneOf"; values: readonly unknown[] }
  | {
      op: "range";
      min: number | string;
      max: number | string;
      inclusive?: boolean;
    }
  | {
      op: "min" | "max";
      count?: number;
      groupBy?: string | readonly string[];
      ties?: "first" | "all";
    }
);

Related types: MarkGraphicProperty.

`MeanConfidenceIntervalMethod`

Expand MeanConfidenceIntervalMethod

export type MeanConfidenceIntervalMethod = ConfidenceIntervalMethod | BootstrapMeanIntervalMethod;

`MeasuredRadialGuideOptions`

Expand MeasuredRadialGuideOptions

export type MeasuredRadialGuideOptions = {
  axes?: false | CategoricalPolarAxesOptions;
  grid?: false | CategoricalPolarGridOptions;
  legend?: false | PieLegendOptions;
};

`MeasuredRadiusScaleOptions`

Expand MeasuredRadiusScaleOptions

export type MeasuredRadiusScaleOptions = Pick<RadiusScaleOptions, "id" | "domain" | "range" | "clamp"> & {
  type?: "linear";
  zero?: true;
  nice?: false;
  reverse?: false;
};

Related types: RadiusScaleOptions.

`NamedCompleteAxis`

Expand NamedCompleteAxis

export type NamedCompleteAxis<P extends string> = CompleteAxisOptions<P> & { id: string };

Related types: CompleteAxisOptions.

`NonCartesianStrokeDashChannel`

Expand NonCartesianStrokeDashChannel

type NonCartesianStrokeDashChannel = BasicStrokeDashChannel extends infer T
  ? T extends { field: string } ? Omit<T, "scale"> & { scale?: Omit<DashScaleOptions, "unknown"> } : T
  : never;

Related types: BasicStrokeDashChannel · DashScaleOptions.

`NonPointBandPositionScaleOptions`

Expand NonPointBandPositionScaleOptions

export type NonPointBandPositionScaleOptions = ScaleFields<
  "id" | "reverse" | "paddingInner" | "paddingOuter" | "align"
> & {
  type?: "band";
  domain?: "auto" | readonly unknown[];
  range?: "auto" | readonly [number, number];
};

Related types: ScaleFields.

`NonPointCategoricalColorScaleOptions`

Expand NonPointCategoricalColorScaleOptions

export type NonPointCategoricalColorScaleOptions = ScaleFields<"id" | "palette"> & {
  type?: "ordinal";
  domain?: "auto" | readonly unknown[];
  range?: "auto" | readonly string[] | { readonly palette: Palette };
};

Related types: ScaleFields · Palette.

`NonPointCategoricalPositionScaleOptions`

Expand NonPointCategoricalPositionScaleOptions

export type NonPointCategoricalPositionScaleOptions =
  | NonPointBandPositionScaleOptions
  | NonPointPointPositionScaleOptions;

`NonPointContinuousColorScaleOptions`

Expand NonPointContinuousColorScaleOptions

export type NonPointContinuousColorScaleOptions = ScaleFields<
  "id" | "interpolate" | "whitePoint" | "gamma" | "midpoint" | "clamp" | "reverse"
> & {
  base?: number;
  constant?: number;
  domain?: "auto" | readonly [unknown, unknown];
  range?: "auto" | readonly [string, string, ...string[]] | { readonly palette: Palette };
  palette?: Palette;
} & (
  | { type: "pow"; exponent?: number }
  | { type?: "sequential" | "log" | "sqrt" | "symlog"; exponent?: never }
);

Related types: ScaleFields · Palette.

`NonPointDiscretizedColorScaleOptions`

Expand NonPointDiscretizedColorScaleOptions

export type NonPointDiscretizedColorScaleOptions =
  | NonPointQuantizeColorScaleOptions
  | NonPointQuantileColorScaleOptions
  | NonPointThresholdColorScaleOptions;

`NonPointPointPositionScaleOptions`

Expand NonPointPointPositionScaleOptions

export type NonPointPointPositionScaleOptions = ScaleFields<
  "id" | "reverse" | "padding" | "align"
> & {
  type?: "point";
  domain?: "auto" | readonly unknown[];
  range?: "auto" | readonly [number, number];
};

Related types: ScaleFields.

`NonPointQuantileColorScaleOptions`

Expand NonPointQuantileColorScaleOptions

export type NonPointQuantileColorScaleOptions = ScaleFields<"id" | "reverse"> & {
  type: "quantile";
  domain?: "auto" | readonly number[];
  range?: "auto" | readonly [string, string, ...string[]];
  palette?: PaletteName | { name: PaletteName; count?: number };
};

Related types: ScaleFields · PaletteName.

`NonPointQuantitativePositionScaleOptions`

Expand NonPointQuantitativePositionScaleOptions

export type NonPointQuantitativePositionScaleOptions = ScaleFields<
  "id" | "zero" | "clamp" | "reverse" |
  "base" | "exponent" | "constant"
> & {
  domain?: "auto" | readonly [number, number];
  range?: "auto" | readonly [number, number];
} & (
  | { type?: "linear"; nice?: boolean | LinearNiceCountOptions }
  | { type: Exclude<QuantitativePositionScaleType, "linear">; nice?: boolean }
);

`NonPointQuantizeColorScaleOptions`

Expand NonPointQuantizeColorScaleOptions

export type NonPointQuantizeColorScaleOptions = ScaleFields<
  "id" | "clamp" | "reverse"
> & {
  type: "quantize";
  domain?: "auto" | readonly [number, number];
  range?: "auto" | readonly [string, string, ...string[]];
  palette?: PaletteName | { name: PaletteName; count?: number };
};

Related types: ScaleFields · PaletteName.

`NonPointTemporalPositionScaleOptions`

Expand NonPointTemporalPositionScaleOptions

export type NonPointTemporalPositionScaleOptions = ScaleFields<
  "id" | "clamp" | "reverse"
> & {
  type?: "time";
  nice?: boolean;
  domain?: "auto" | readonly [number, number];
  range?: "auto" | readonly [number, number];
};

Related types: ScaleFields.

`NonPointThresholdColorScaleOptions`

Expand NonPointThresholdColorScaleOptions

export type NonPointThresholdColorScaleOptions = ScaleFields<"id" | "reverse"> & {
  type: "threshold";
  domain: readonly number[];
  range?: "auto" | readonly [string, string, ...string[]];
  palette?: PaletteName | { name: PaletteName; count?: number };
};

Related types: ScaleFields · PaletteName.

`NonPointZeroSupportingPositionScaleOptions`

Expand NonPointZeroSupportingPositionScaleOptions

export type NonPointZeroSupportingPositionScaleOptions = Omit<
  NonPointQuantitativePositionScaleOptions,
  "base" | "type" | "nice"
> & (
  | { type?: "linear"; nice?: boolean | LinearNiceCountOptions }
  | { type: Exclude<ZeroSupportingPositionScaleType, "linear">; nice?: boolean }
);

`NormalizeBaseline`

Expand NormalizeBaseline

export type NormalizeBaseline =
  | { readonly position: "first" | "last" }
  | { readonly value: number };

`NormalizeBaselineOptions`

Expand NormalizeBaselineOptions

type NormalizeBaselineOptions =
  | {
      baseline?: { position: "first" | "last" };
      sortBy: readonly [WindowSort, ...WindowSort[]];
    }
  | {
      baseline: { value: number };
      sortBy?: readonly WindowSort[];
    };

Related types: WindowSort.

`NormalizeZeroDenominator`

Expand NormalizeZeroDenominator

export type NormalizeZeroDenominator = "error" | "null" | "zero";

`NormalizedDataBaseOptions`

Expand NormalizedDataBaseOptions

type NormalizedDataBaseOptions = {
  id: string;
  source?: string;
  field: string;
  as: string;
  groupBy?: string | readonly string[];
};

`NormalizedDataOptions`

Expand NormalizedDataOptions

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)
);

`NumericFormatString`

Expand NumericFormatString

export type NumericFormatString =
  | `.${ValueFormatPrecision}${"f" | "%" | "e"}`
  | ","
  | `,.${ValueFormatPrecision}f`;

Related types: ValueFormatPrecision.

`OffsetEncodingOptions`

Expand OffsetEncodingOptions

export interface OffsetEncodingOptions {
  field: string;
  target?: string;
  fieldType?: "nominal" | "ordinal";
  scale?: OffsetScaleOptions;
  paddingInner?: number;
  paddingOuter?: number;
}

Related types: OffsetScaleOptions.

`OffsetScaleEditPatch`

Expand OffsetScaleEditPatch

export type OffsetScaleEditPatch = Pick<
  ScaleOptions,
  "domain" | "reverse" | "padding" | "paddingInner" | "paddingOuter" | "align"
>;

Related types: ScaleOptions.

`OffsetScaleOptions`

Expand OffsetScaleOptions

export interface OffsetScaleOptions {
  id?: string;
  type?: "ordinal";
  domain?: "auto" | readonly unknown[];
  reverse?: boolean;
  padding?: number;
  paddingInner?: number;
  paddingOuter?: number;
  align?: number;
}

`OpacityEncodingOptions`

Expand OpacityEncodingOptions

export type OpacityEncodingOptions =
  | { value: number; field?: never; target?: string; fieldType?: never; scale?: never }
  | {
      field: string;
      value?: never;
      target?: string;
      fieldType?: "quantitative";
      scale?: OpacityScaleOptions;
    };

Related types: OpacityScaleOptions.

`OpacityScaleOptions`

Expand OpacityScaleOptions

export type OpacityScaleOptions = ScaleFields<
  "id" | "zero" | "clamp" | "reverse"
> & {
  nice?: boolean;
  type?: "linear";
  domain?: "auto" | readonly [number, number];
  range?: "auto" | readonly [number, number];
  unknown?: number;
};

/** Constant or quantitative opacity on Point, Rule, Line, Bar, or row-owned Rect marks. */

Related types: ScaleFields.

`OrderCategoriesOptions`

Expand OrderCategoriesOptions

export type OrderCategoriesOptions = {
  target?: string;
  channel: "x" | "y" | "theta";
} & CategoryOrder;

Related types: CategoryOrder.

`PackPointsOptions`

Expand PackPointsOptions

export interface PackPointsOptions {
  target?: string;
  channel: "x" | "y";
  maxOffset?: PointPackingMaxOffset;
  padding?: number;
  key?: string;
  overflow?: "error" | "overlap";
}

Related types: PointPackingMaxOffset.

`Palette`

Expand Palette

export type Palette = PaletteName | {
  name: PaletteName;
  count?: number;
  extent?: readonly [number, number];
};

Related types: PaletteName.

`PaletteName`

Expand PaletteName

export type PaletteName =
  | "accent"
  | "category10" | "category20" | "category20b" | "category20c"
  | "observable10"
  | "dark2" | "paired" | "pastel1" | "pastel2"
  | "set1" | "set2" | "set3"
  | "tableau10" | "tableau20"
  | "blues" | "tealblues" | "teals" | "greens" | "browns"
  | "oranges" | "reds" | "purples" | "warmgreys" | "greys"
  | "viridis" | "magma" | "inferno" | "plasma" | "cividis" | "turbo"
  | "bluegreen" | "bluepurple"
  | "goldgreen" | "goldorange" | "goldred"
  | "greenblue" | "orangered"
  | "purplebluegreen" | "purpleblue" | "purplered" | "redpurple"
  | "yellowgreenblue" | "yellowgreen" | "yelloworangebrown" | "yelloworangered"
  | "darkblue" | "darkgold" | "darkgreen" | "darkmulti" | "darkred"
  | "lightgreyred" | "lightgreyteal" | "lightmulti" | "lightorange" | "lighttealblue"
  | "blueorange" | "brownbluegreen" | "purplegreen" | "pinkyellowgreen"
  | "purpleorange" | "redblue" | "redgrey"
  | "redyellowblue" | "redyellowgreen" | "spectral"
  | "rainbow" | "sinebow";

`ParallelAxesOptions`

Expand ParallelAxesOptions

export interface ParallelAxesOptions { target?: string; coordinate?: string; }

`ParallelAxisComponentsOptions`

Expand ParallelAxisComponentsOptions

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 }
);

`ParallelAxisLabelsOptions`

Expand ParallelAxisLabelsOptions

export type ParallelAxisLabelsOptions = AxisLabelStyleOptions & ParallelAxisTickSelection;

`ParallelAxisTickSelection`

Expand ParallelAxisTickSelection

export type ParallelAxisTickSelection =
  | { count?: number; values?: never }
  | { values: readonly AxisValue[]; count?: never };

Related types: AxisValue.

`ParallelAxisTicksOptions`

Expand ParallelAxisTicksOptions

export type ParallelAxisTicksOptions = AxisTickStyleOptions & ParallelAxisTickSelection;

`ParallelAxisTitleOptions`

Expand ParallelAxisTitleOptions

export interface ParallelAxisTitleOptions {
  text?: string;
  offset?: number;
  color?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
}

`ParallelCoordinatesEncodingOptions`

Expand ParallelCoordinatesEncodingOptions

export interface ParallelCoordinatesEncodingOptions {
  target?: string;
  coordinate?: string;
  dimensions: readonly [ParallelDimension, ParallelDimension, ...ParallelDimension[]];
  key?: string;
  missing?: ParallelMissingPolicy;
}

Related types: ParallelDimension · ParallelMissingPolicy.

`ParallelDimension`

Expand ParallelDimension

export type ParallelDimension = string | ({
  field: string;
  title?: string;
} & (
  | {
      fieldType: "quantitative";
      scale?: WithoutScaleId<QuantitativePositionScaleOptions>;
    }
  | {
      fieldType: "ordinal";
      scale?: WithoutScaleId<CategoricalPositionScaleOptions>;
    }
  | {
      fieldType?: undefined;
      scale?: WithoutScaleId<
        QuantitativePositionScaleOptions | CategoricalPositionScaleOptions
      >;
    }
));

`ParallelGuideOptions`

Expand ParallelGuideOptions

type ParallelGuideOptions = {
  axes?: false | {
    coordinate?: { id?: string; type?: "auto" | "parallel" };
  };
  grid?: false;
  legend?: false | (Omit<PathLegendOptions, "order"> & { order?: LegendValueOrder });
};

Related types: PathLegendOptions · LegendValueOrder.

`ParallelMissingPolicy`

Expand ParallelMissingPolicy

export type ParallelMissingPolicy = "break" | "drop-row" | "error";

`ParameterizedAggregateOperation`

Expand ParameterizedAggregateOperation

export type ParameterizedAggregateOperation =
  | { op: "quantile"; probability: number }
  | {
      op: "first" | "last";
      orderBy: string;
      order?: "ascending" | "descending";
    }
  | {
      op: "ciLower" | "ciUpper";
      method?: ConfidenceIntervalMethod;
      level?: number;
    };

Related types: ConfidenceIntervalMethod.

`ParseTimeFormat`

Expand ParseTimeFormat

export type ParseTimeFormat = "auto" | "%Y-%m-%d" | "%d/%m/%Y" | "%m/%d/%Y";

`PathLegendOptions`

Expand PathLegendOptions

type PathLegendOptions = Omit<
  LegendOptions,
  "symbol" | "gradient" | "count" | "values" | "labels" | "representation" | "combine" | "titlePosition"
> & {
  titlePosition?: "top" | "left";
  combine?: "separate";
  symbol?: "auto" | { length?: number; lineWidth?: number }
    | { layers: readonly LegendSymbolLayer[] };
  labels?: CategoricalLegendTextOptions;
};

`PathOrderEncodingOptions`

Expand PathOrderEncodingOptions

export interface PathOrderEncodingOptions {
  target?: string;
  field: string;
  fieldType?: "quantitative";
  order?: "ascending" | "descending";
}

`PieCategory`

Expand PieCategory

export type PieCategory = string | {
  field: string;
  fieldType?: "nominal" | "ordinal";
  scale?: Pick<ThetaScaleOptions, "id" | "domain" | "range" | "reverse"> & { type?: "band" };
};

Related types: ThetaScaleOptions.

`PieColor`

Expand PieColor

export type PieColor = string | {
  field: string;
  fieldType?: "nominal" | "ordinal";
  scale?: NonPointCategoricalColorScaleOptions;
  palette?: Palette;
};

`PieLegendOptions`

Expand PieLegendOptions

export type PieLegendOptions = Omit<
  SeparateFilledLegendOptions,
  "count" | "values" | "gradient" | "channels" | "order" | "labels" | "representation" | "symbol" | "titlePosition"
> & {
  titlePosition?: "top" | "left";
  symbol?: FilledLegendSymbolRecipe;
  channels?: readonly ["color"];
  order?: LegendValueOrder | { channel: "theta"; values?: never };
  labels?: CategoricalLegendTextOptions;
};

`PieRadiusChannel`

Expand PieRadiusChannel

export type PieRadiusChannel = string | {
  scale?: RadiusScaleOptions;
} & ({ field: string; aggregate?: "sum" } | { field?: never; aggregate: "count" });

Related types: RadiusScaleOptions.

`PointFacadePositionChannel`

Expand PointFacadePositionChannel

type PointFacadePositionChannel =
  | string
  | ({ field: string } & (
      | {
          fieldType?: "quantitative";
          scale?: QuantitativePositionScaleOptions;
        }
      | {
          fieldType: "temporal";
          temporalUnit?: TemporalInputUnit;
          scale?: TemporalPositionScaleOptions;
        }
      | {
          fieldType: "nominal" | "ordinal";
          scale?: CategoricalPositionScaleOptions;
        }
    ));

`PointPackingMaxOffset`

Expand PointPackingMaxOffset

export type PointPackingMaxOffset =
  | { pixels: number; band?: never }
  | { pixels?: never; band: number };

`PointPolygonShape`

Expand PointPolygonShape

export type PointPolygonShape = {
  polygon: readonly { x: number; y: number }[];
  normalization?: "area" | "radius";
};

`PointPositionScaleOptions`

Expand PointPositionScaleOptions

export type PointPositionScaleOptions =
  NonPointPointPositionScaleOptions & { unknown?: number };

Related types: NonPointPointPositionScaleOptions.

`PointShape`

Expand PointShape

export type PointShape =
  | "circle"
  | "square"
  | "diamond"
  | "triangle-up"
  | "triangle-down"
  | "triangle-left"
  | "triangle-right"
  | "plus"
  | "cross"
  | "star"
  | "hexagon"
  | "wye"
  | "wedge"
  | "arrow"
  | PointPolygonShape;

Related types: PointPolygonShape.

`PolarAxisTickSelection`

Expand PolarAxisTickSelection

export type PolarAxisTickSelection =
  | { count?: number; values?: never }
  | { values: readonly AxisValue[]; count?: never };

Related types: AxisValue.

`PolarChartGuideOptions`

Expand PolarChartGuideOptions

export type PolarChartGuideOptions = {
  axes?: false | Pick<CreateAxesOptions, "theta" | "radius"> & {
    coordinate?: { id?: string; type?: "auto" | "polar" };
  };
  grid?: false | Pick<CreateGridOptions, "theta" | "radial">;
  legend?: false | LegendOptions;
};

Related types: CreateAxesOptions · CreateGridOptions · LegendOptions.

`PolarFrameCenter`

Expand PolarFrameCenter

export type PolarFrameCenter = {
  x: number;
  y: number;
};

`PolarFrameOptions`

Expand PolarFrameOptions

export type PolarFrameOptions = "auto" | {
  center?: PolarFrameCenter;
  radius?: PolarFrameRadius;
  overflow?: "error" | "allow";
};

Related types: PolarFrameCenter · PolarFrameRadius.

`PolarFrameRadius`

Expand PolarFrameRadius

export type PolarFrameRadius =
  | { unit: "fraction"; value: number }
  | { unit: "px"; value: number };

`PolarGridOptions`

Expand PolarGridOptions

export interface PolarGridOptions {
  scale?: string;
  coordinate?: string;
  count?: number;
  values?: readonly AxisValue[];
  color?: string;
  lineWidth?: number;
  strokeDash?: readonly number[];
}

Related types: AxisValue.

`PolarGuideResourceOptions`

Expand PolarGuideResourceOptions

export interface PolarGuideResourceOptions {
  scale?: string;
  coordinate?: string;
  angle?: number;
}

`PolarLabelOptions`

Expand PolarLabelOptions

export interface PolarLabelOptions extends AxisLabelStyleOptions {
  count?: number;
  values?: readonly AxisValue[];
}

Related types: AxisLabelStyleOptions · AxisValue.

`PolarLegendOrder`

Expand PolarLegendOrder

type PolarLegendOrder = LegendValueOrder | { channel: "theta"; values?: never };

Related types: LegendValueOrder.

`PolarPathGuideOptions`

Expand PolarPathGuideOptions

export type PolarPathGuideOptions = Omit<PolarChartGuideOptions, "legend"> & {
  legend?: false | PolarPathLegendOptions;
};

`PolarPathLegendOptions`

Expand PolarPathLegendOptions

type PolarPathLegendOptions = Omit<PathLegendOptions, "order"> & {
  order?: PolarLegendOrder;
};

Related types: PathLegendOptions · PolarLegendOrder.

`PolarPointGuideOptions`

Expand PolarPointGuideOptions

export type PolarPointGuideOptions = Omit<PolarChartGuideOptions, "legend"> & {
  legend?: false | PolarPointLegendOptions;
};

`PolarPointLegendOptions`

Expand PolarPointLegendOptions

type PolarPointLegendOptions = DistributiveLegendOmit<Exclude<FilledMarkLegendOptions, { combine: "color-size" }>, "order"> & {
  order?: PolarLegendOrder;
};

`PolarRadiusChannel`

Expand PolarRadiusChannel

export type PolarRadiusChannel = string | {
  field: string;
  fieldType?: "quantitative";
  scale?: RadiusScaleOptions;
};

Related types: RadiusScaleOptions.

`PolarThetaChannel`

Expand PolarThetaChannel

export type PolarThetaChannel = string | ({ field: string; scale?: ThetaScaleOptions } & (
  | { fieldType?: "quantitative" | "nominal" | "ordinal"; temporalUnit?: never }
  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit }
));

Related types: ThetaScaleOptions · TemporalInputUnit.

`PolarTickOptions`

Expand PolarTickOptions

export interface PolarTickOptions extends AxisTickStyleOptions {
  count?: number;
  values?: readonly AxisValue[];
}

Related types: AxisTickStyleOptions · AxisValue.

`PolarTicksAndLabelsOptions`

Expand PolarTicksAndLabelsOptions

export interface PolarTicksAndLabelsOptions {
  count?: number;
  values?: readonly AxisValue[];
  ticks?: AxisTickStyleOptions;
  labels?: AxisLabelStyleOptions;
}

`PolarTitleOptions`

Expand PolarTitleOptions

export interface PolarTitleOptions {
  text?: string;
  offset?: number;
  color?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
}

`PositionEncodingBase`

Expand PositionEncodingBase

interface PositionEncodingBase {
  field: string;
  target?: string;
  coordinate?: string;
  bin?:
    | { maxBins?: number; step?: never; boundaries?: never }
    | { maxBins?: never; step: number; boundaries?: never }
    | {
        maxBins?: never;
        step?: never;
        boundaries: readonly [number, number, ...number[]];
      };
  stack?: StackMode;
}

Related types: StackMode.

`PositionEncodingOptions`

Expand PositionEncodingOptions

export type PositionEncodingOptions = PositionEncodingBase & PositionScaleBranches<
  QuantitativePositionScaleOptions,
  TemporalPositionScaleOptions,
  CategoricalPositionScaleOptions
>;

`PositionScaleBranches`

Expand PositionScaleBranches

type PositionScaleBranches<Quantitative, Temporal, Categorical> =
  | {
      fieldType?: "quantitative";
      aggregate?: never;
      scale?: Quantitative;
    }
  | {
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      aggregate?: never;
      scale?: Temporal;
    }
  | {
      fieldType: "nominal" | "ordinal";
      aggregate?: never;
      scale?: Categorical;
    }
  | {
      fieldType?: FieldType;
      aggregate: AggregateOperation;
      scale?: Quantitative;
    };

Related types: TemporalInputUnit · FieldType · AggregateOperation.

`PreGriddedHeatmapOptions`

Expand PreGriddedHeatmapOptions

export interface PreGriddedHeatmapOptions extends HeatmapBaseOptions {
  x: HeatmapCategoryPositionChannel;
  y: HeatmapCategoryPositionChannel;
  bin?: never;
  color?: RectColorChannel;
}

`QuantileColorScaleOptions`

Expand QuantileColorScaleOptions

export type QuantileColorScaleOptions =
  NonPointQuantileColorScaleOptions & { unknown?: string };

Related types: NonPointQuantileColorScaleOptions.

`QuantitativeBarColorChannel`

Expand QuantitativeBarColorChannel

type QuantitativeBarColorChannel = {
  field: string;
  fieldType: "quantitative";
  aggregate?: AggregateOperation;
  scale?:
    | NonPointContinuousColorScaleOptions
    | NonPointDiscretizedColorScaleOptions;
  palette?: Palette;
  layout?: never;
};

`QuantitativePositionScaleOptions`

Expand QuantitativePositionScaleOptions

export type QuantitativePositionScaleOptions =
  NonPointQuantitativePositionScaleOptions & { unknown?: number };

`QuantitativePositionScaleType`

Expand QuantitativePositionScaleType

export type QuantitativePositionScaleType =
  | "linear" | "log" | "pow" | "sqrt" | "symlog";

`QuantitativeRangePositionEncodingOptions`

Expand QuantitativeRangePositionEncodingOptions

type QuantitativeRangePositionEncodingOptions = {
  lower: string | { datum: number };
  upper: string | { datum: number };
  target?: string;
  coordinate?: string;
  fieldType?: "quantitative";
  temporalUnit?: never;
  scale?: NonPointQuantitativePositionScaleOptions;
};

`QuantizeColorScaleOptions`

Expand QuantizeColorScaleOptions

export type QuantizeColorScaleOptions =
  NonPointQuantizeColorScaleOptions & { unknown?: string };

Related types: NonPointQuantizeColorScaleOptions.

`RadarCategoryChannel`

Expand RadarCategoryChannel

export type RadarCategoryChannel = string | {
  field: string;
  fieldType?: "nominal" | "ordinal";
  scale?: RadarCategoryScaleOptions;
};

Related types: RadarCategoryScaleOptions.

`RadarCategoryScaleOptions`

Expand RadarCategoryScaleOptions

export type RadarCategoryScaleOptions = Pick<
  ThetaScaleOptions,
  "id" | "domain" | "range" | "reverse" | "paddingInner" | "paddingOuter" |
  "padding" | "align"
> & { type?: "band" | "point" };

Related types: ThetaScaleOptions.

`RadarCategoryValue`

Expand RadarCategoryValue

export type RadarCategoryValue = string | number | boolean;

`RadarGuideOptions`

Expand RadarGuideOptions

export type RadarGuideOptions = Omit<PolarPathGuideOptions, "axes" | "grid" | "legend"> & {
  axes?: false | CategoricalPolarAxesOptions;
  grid?: false | CategoricalPolarGridOptions;
  legend?: false | (Omit<PathLegendOptions, "order"> & { order?: LegendValueOrder });
};

`RadarWideOptions`

Expand RadarWideOptions

export interface RadarWideOptions {
  fields: readonly [string, string, string, ...string[]];
  as?: { key?: string; value?: string };
}

`RadialEncodingOptions`

Expand RadialEncodingOptions

export type RadialEncodingOptions = {
  target?: string;
  fieldType?: "quantitative";
  coordinate?: string;
} & (
  | { field: string; mapping?: false; aggregate?: never; scale?: RadiusScaleOptions }
  | { field: string; mapping?: never; aggregate: "sum"; scale?: RadiusScaleOptions }
  | { field?: never; mapping?: never; aggregate: "count"; scale?: RadiusScaleOptions }
  | { field: string; mapping?: RadialMapping; aggregate: "sum"; scale?: MeasuredRadiusScaleOptions }
  | { field?: never; mapping?: RadialMapping; aggregate: "count"; scale?: MeasuredRadiusScaleOptions }
);

`RadialMapping`

Expand RadialMapping

export type RadialMapping = "area" | "radius-length";

/** Automatic linear position-domain rounding density, not a guide tick count. */

`RadialTitleOptions`

Expand RadialTitleOptions

export interface RadialTitleOptions extends PolarTitleOptions {
  position?: "inside" | "outside";
}

Related types: PolarTitleOptions.

`RadiusScaleOptions`

Expand RadiusScaleOptions

export interface RadiusScaleOptions {
  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;
}

`RaincloudBoxSummaryOptions`

Expand RaincloudBoxSummaryOptions

export interface RaincloudBoxSummaryOptions {
  type?: "box";
  whisker?: BoxPlotWhisker;
  width?: { band?: number };
  outliers?: boolean;
  box?: BoxPlotOptions["box"];
  median?: BoxPlotOptions["median"];
  outlier?: BoxPlotOptions["outlier"];
}

Related types: BoxPlotWhisker · BoxPlotOptions.

`RaincloudCategoryChannel`

Expand RaincloudCategoryChannel

export type RaincloudCategoryChannel = string | {
  field: string;
  fieldType?: "nominal" | "ordinal";
  scale?: NonPointBandPositionScaleOptions;
};

Related types: NonPointBandPositionScaleOptions.

`RaincloudColorChannel`

Expand RaincloudColorChannel

export type RaincloudColorChannel = LineCategoricalColorChannel | { value: string };

Related types: LineCategoricalColorChannel.

`RaincloudDensityOptions`

Expand RaincloudDensityOptions

export interface RaincloudDensityOptions extends GradientPlotDensityOptions {
  width?: DensityPlacementWidth;
  area?: ViolinPlotAreaOptions;
}

`RaincloudIntervalSummaryOptions`

Expand RaincloudIntervalSummaryOptions

export interface RaincloudIntervalSummaryOptions {
  type: "interval";
  center?: IntervalCenter;
  extent?: IntervalExtent;
  method?: ConfidenceIntervalMethod;
  level?: number;
  point?: CreateScatterPlotOptions["point"];
  errorBar?: IntervalPlotErrorBarOptions;
}

`RaincloudPointAppearanceOptions`

Expand RaincloudPointAppearanceOptions

export interface RaincloudPointAppearanceOptions {
  size?: BasicSizeChannel;
  shape?: BasicShapeChannel;
  point?: CreateScatterPlotOptions["point"];
}

`RaincloudPointsOptions`

Expand RaincloudPointsOptions

export type RaincloudPointsOptions =
  | (RaincloudPointAppearanceOptions & {
      type: "strip";
      jitter?: false | StripBandJitterOptions;
      packing?: never;
    })
  | (RaincloudPointAppearanceOptions & {
      type?: "beeswarm";
      packing?: false | BeeswarmPackingOptions;
      jitter?: never;
    });

`RaincloudSummaryOptions`

Expand RaincloudSummaryOptions

export type RaincloudSummaryOptions =
  | RaincloudBoxSummaryOptions
  | RaincloudIntervalSummaryOptions;

`RaincloudValueChannel`

Expand RaincloudValueChannel

export type RaincloudValueChannel = string | {
  field: string;
  fieldType?: "quantitative";
  scale?: NonPointQuantitativePositionScaleOptions;
};

`RangePositionEncodingOptions`

Expand RangePositionEncodingOptions

type RangePositionEncodingOptions = QuantitativeRangePositionEncodingOptions | {
  lower: string;
  upper: string;
  target?: string;
  coordinate?: string;
  fieldType: "temporal";
  temporalUnit?: TemporalInputUnit;
  scale?: NonPointTemporalPositionScaleOptions;
};

`RectColorChannel`

Expand RectColorChannel

type RectColorChannel =
  | LineCategoricalColorChannel
  | {
      field: string;
      fieldType: "quantitative";
      scale?:
        | NonPointContinuousColorScaleOptions
        | NonPointDiscretizedColorScaleOptions;
      palette?: Palette;
    }
  | {
      field: string;
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      scale?: Omit<NonPointContinuousColorScaleOptions, "midpoint" | "type" | "base" | "exponent" | "constant"> & { midpoint?: "auto"; type?: "sequential" };
      palette?: Palette;
    };

`RectMarkOptions`

Expand RectMarkOptions

export interface RectMarkOptions extends RectStyleDetails {
  clip?: boolean;
  id?: string;
  data?: string;
  missing?: "error" | "skip";
  fill?: string;
  opacity?: number;
  stroke?: string | false;
  strokeWidth?: number;
}

Related types: RectStyleDetails.

`RectStyleDetails`

Expand RectStyleDetails

export type RectStyleDetails = StrokeStyleDetails & {
  cornerRadius?: number;
  cornerRadiusTopLeft?: number;
  cornerRadiusTopRight?: number;
  cornerRadiusBottomRight?: number;
  cornerRadiusBottomLeft?: number;
};

Related types: StrokeStyleDetails.

`ReferenceAxis`

Expand ReferenceAxis

type ReferenceAxis<Value> = { x: Value; y?: never } | { y: Value; x?: never };

`ReferenceBinding`

Expand ReferenceBinding

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>);

Related types: TemporalInputUnit · ReferenceAxis.

`ReferenceStatistic`

Expand ReferenceStatistic

export type ReferenceStatistic =
  | { readonly op: "mean" | "median" | "min" | "max"; readonly p?: never }
  | { readonly op: "quantile"; readonly p: number };

`RegressionBandOptions`

Expand RegressionBandOptions

export interface RegressionBandOptions extends StrokeStyleDetails {
  color?: string;
  opacity?: number;
  stroke?: string;
  strokeWidth?: number;
  curve?: CurveInterpolation;
}

Related types: StrokeStyleDetails · CurveInterpolation.

`RegressionCommonOptions`

Expand RegressionCommonOptions

type RegressionCommonOptions = {
  placement?: "source" | "plot-last";
  target?: string;
  x?: string;
  y?: string;
  groupBy?: string | false;
  line?: StrokeStyleDetails & { strokeWidth?: number; curve?: CurveInterpolation };
  sourceBinding?: "fixed" | "follow";
  missing?: "error" | "drop";
};

Related types: StrokeStyleDetails · CurveInterpolation.

`RegressionDataOptions`

Expand RegressionDataOptions

export type RegressionDataOptions = {
  id: string;
  source?: string;
  x: string;
  y: string;
  groupBy?: string;
  missing?: "error" | "drop";
} & RegressionParameterOptions;

Related types: RegressionParameterOptions.

`RegressionInterval`

Expand RegressionInterval

export type RegressionInterval = "mean" | "prediction";

`RegressionMethod`

Expand RegressionMethod

export type RegressionMethod = "linear" | "polynomial" | "loess" | "exp";

`RegressionOptions`

Expand RegressionOptions

export type RegressionOptions = RegressionCommonOptions & (
  | (Extract<RegressionParameterOptions, { method: "exp" }> & {
      band?: false;
    })
  | (Extract<RegressionParameterOptions, { method?: "linear" }> & {
      band?: false | RegressionBandOptions;
    })
  | (Extract<RegressionParameterOptions, { method: "polynomial" }> & {
      band?: false | RegressionBandOptions;
    })
  | (Extract<RegressionParameterOptions, { method: "loess" }> & {
      band?: false;
    })
);

`RegressionParameterOptions`

Expand RegressionParameterOptions

type RegressionParameterOptions =
  | {
      method: "exp";
      interval?: false;
      degree?: never;
      span?: never;
      robustIterations?: never;
      confidenceMethod?: never;
      level?: never;
      confidence?: never;
      predict?: RegressionPredictOptions;
    }
  | {
      method?: "linear";
      degree?: never;
      span?: never;
      robustIterations?: never;
      confidenceMethod?: ConfidenceIntervalMethod;
      level?: number;
      confidence?: number;
      interval?: RegressionInterval | false;
      predict?: RegressionPredictOptions;
    }
  | {
      method: "polynomial";
      degree?: number;
      span?: never;
      robustIterations?: never;
      confidenceMethod?: ConfidenceIntervalMethod;
      level?: number;
      confidence?: number;
      interval?: RegressionInterval | false;
      predict?: RegressionPredictOptions;
    }
  | {
      method: "loess";
      degree?: never;
      span?: number;
      /** Residual reweighting passes, integer 0..32; default 0. */
      robustIterations?: number;
      confidenceMethod?: never;
      level?: never;
      confidence?: never;
      interval?: never;
      predict?: RegressionPredictOptions;
    };

`RegressionPlotBaseOptions`

Expand RegressionPlotBaseOptions

type RegressionPlotBaseOptions = {
  id?: string;
  data?: string;
  coordinate?: string;
  x: RegressionPlotPositionChannel;
  y: RegressionPlotPositionChannel;
  color?: BasicColorChannel;
  size?: BasicSizeChannel;
  shape?: BasicShapeChannel;
  point?: CreateScatterPlotOptions["point"];
  guides?: false | CartesianGuideOptions;
};

`RegressionPlotPositionChannel`

Expand RegressionPlotPositionChannel

export type RegressionPlotPositionChannel = string | {
  field: string;
  fieldType?: "quantitative";
  scale?: NonPointQuantitativePositionScaleOptions;
};

`RegressionPlotStatisticalOptions`

Expand RegressionPlotStatisticalOptions

type RegressionPlotStatisticalOptions<T> = T extends unknown
  ? Omit<T, "target" | "x" | "y">
  : never;

`RegressionPredictOptions`

Expand RegressionPredictOptions

export type RegressionPredictOptions =
  | { values: readonly [number, ...number[]]; domain?: never; steps?: never }
  | { values?: never; domain: readonly [number, number]; steps: number };

`RegressionStatisticsDataOptions`

Expand RegressionStatisticsDataOptions

export interface RegressionStatisticsDataOptions {
  id: string;
  source: string;
}

`RemoveAxisOptions`

Expand RemoveAxisOptions

export interface RemoveAxisOptions {
  target?: string;
  coordinate?: string;
  scale?: string;
}

`RemoveCategoryOrderOptions`

Expand RemoveCategoryOrderOptions

export interface RemoveCategoryOrderOptions {
  target?: string;
  channel: "x" | "y" | "theta";
}

`RemoveCompositionChildOptions`

Expand RemoveCompositionChildOptions

export interface RemoveCompositionChildOptions { target: string; }

`RemoveGridOptions`

Expand RemoveGridOptions

export interface RemoveGridOptions {
  horizontal?: boolean;
  vertical?: boolean;
  theta?: boolean;
  radial?: boolean;
}

`RemoveJitterOptions`

Expand RemoveJitterOptions

export interface RemoveJitterOptions {
  target?: string;
}

`RemoveLabelLayoutOptions`

Expand RemoveLabelLayoutOptions

export interface RemoveLabelLayoutOptions {
  target?: string;
}

`RemoveLegendOptions`

Expand RemoveLegendOptions

export interface RemoveLegendOptions {
  target?: string;
  /** Remove selected content, including part of a combined categorical legend; omission removes every owned block. */
  channels?: readonly ("color" | "stroke" | "strokeDash" | "strokeWidth" | "shape" | "size" | "opacity")[];
}

`RemoveMarkFilterOptions`

Expand RemoveMarkFilterOptions

export interface RemoveMarkFilterOptions {
  target?: string;
}

`RemoveMarkLabelsOptions`

Expand RemoveMarkLabelsOptions

export type RemoveMarkLabelsOptions =
  | { target: string; source?: never }
  | { source: string; target?: never };

`RemoveMarkOptions`

Expand RemoveMarkOptions

export interface RemoveMarkOptions {
  target?: string;
}

`RemoveMarkSelectionOptions`

Expand RemoveMarkSelectionOptions

export interface RemoveMarkSelectionOptions {
  selection?: string;
}

`RemoveParallelAxisOptions`

Expand RemoveParallelAxisOptions

export interface RemoveParallelAxisOptions { field: string; target?: string; }

`RemovePathOrderOptions`

Expand RemovePathOrderOptions

export interface RemovePathOrderOptions {
  target?: string;
}

`RemovePointPackingOptions`

Expand RemovePointPackingOptions

export interface RemovePointPackingOptions {
  target?: string;
}

`RemoveResourceOptions`

Expand RemoveResourceOptions

export interface RemoveResourceOptions {
  readonly id: string;
}

`ReorderCompositionChildrenOptions`

Expand ReorderCompositionChildrenOptions

export interface ReorderCompositionChildrenOptions {
  order: readonly [string, ...string[]];
}

`RepeatChartsOptions`

Expand RepeatChartsOptions

export interface RepeatChartsOptions {
  id?: string;
  target?: string;
  channel: "x" | "y" | "theta" | "r" | { parallelDimension: string };
  fields: readonly [string, ...string[]];
  columns?: number;
  gap?: FacetGap;
  align?: CompositionAlign;
  padding?: number | CompositionPadding;
  scales?: FacetScaleResolutions;
  guides?: FacetGuideOptions;
  headers?: FacetHeadersOptions;
  /** Interpret gap between child canvases (default), inner plots, or retained full content (wrapped facets). */
  spacing?: "canvas" | "plot" | "content";
  /** Share the existing top margin rather than adding title/header reservations. Requires plot spacing. */
  topLane?: FacetTopLaneMode;
}

`ReplaceCompositionChildOptions`

Expand ReplaceCompositionChildOptions

export interface ReplaceCompositionChildOptions {
  target: string;
  program: ChartProgram;
}

`RequestedDatasetTransform`

Expand RequestedDatasetTransform

export type RequestedDatasetTransform = RequestedTransform<Exclude<
  DatasetTransform,
  DatasetHorizonTransform | DatasetStatisticalReferenceTransform
>>;

`RequestedTransform`

Expand RequestedTransform

type RequestedTransform<T> = T extends unknown ? Omit<T, "resolved"> : never;

`ReviseDataOptions`

Expand ReviseDataOptions

export interface ReviseDataOptions<Row extends object> extends CreateDataOptions<Row> {
  source: string;
  id: string;
}

Related types: CreateDataOptions.

`RotationInput`

Expand RotationInput

export type RotationInput = number | { value: number; unit: RotationUnit };

Related types: RotationUnit.

`RotationUnit`

Expand RotationUnit

export type RotationUnit = "radians" | "degrees";

`RowWindowFrame`

Expand RowWindowFrame

export type RowWindowFrame = {
  preceding: number;
  following?: number;
  duration?: never;
};

`RugGuideOptions`

Expand RugGuideOptions

export type RugGuideOptions = Omit<CartesianGuideOptions, "axes" | "legend" | "grid"> & {
  axes?: false | CAxes;
  grid?: false | ContinuousCartesianGridOptions;
  legend?: false;
};

`RugMeasureChannel`

Expand RugMeasureChannel

export type RugMeasureChannel = string | (
  | {
      field: string;
      fieldType?: "quantitative";
      temporalUnit?: never;
      scale?: NonPointQuantitativePositionScaleOptions;
    }
  | {
      field: string;
      fieldType: "temporal";
      temporalUnit?: TemporalInputUnit;
      scale?: NonPointTemporalPositionScaleOptions;
    }
);

`RugTickOptions`

Expand RugTickOptions

export interface RugTickOptions extends StrokeStyleDetails {
  clip?: boolean;
  length?: number;
  stroke?: string;
  strokeWidth?: number;
  opacity?: number;
}

Related types: StrokeStyleDetails.

`RulePositionEncodingBase`

Expand RulePositionEncodingBase

type RulePositionEncodingBase = RulePositionValue & {
  target?: string;
  coordinate?: string;
};

Related types: RulePositionValue.

`RulePositionValue`

Expand RulePositionValue

type RulePositionValue =
  | { field: string; datum?: never }
  | { field?: never; datum: unknown };

`RuleStyleOptions`

Expand RuleStyleOptions

export interface RuleStyleOptions extends StrokeStyleDetails {
  stroke?: string;
  strokeWidth?: number;
  strokeDash?: DashStyle | DashPattern;
  opacity?: number;
}

Related types: StrokeStyleDetails · DashStyle · DashPattern.

`ScalarAggregateOperation`

Expand ScalarAggregateOperation

export type ScalarAggregateOperation =
  | "count" | "sum" | "mean" | "median" | "min" | "max"
  | "distinct" | "valid" | "missing"
  | "variance" | "varianceP" | "stdev" | "stdevP" | "stderr"
  | "q1" | "q3" | "ciLower" | "ciUpper";

`ScaleFields`

Expand ScaleFields

type ScaleFields<Keys extends keyof ScaleOptions> = Pick<ScaleOptions, Keys>;

Related types: ScaleOptions.

`ScaleOptions`

Expand ScaleOptions

export interface ScaleOptions {
  radialMapping?: RadialMapping;
  id?: string;
  type?: ScaleType;
  domain?: "auto" | readonly unknown[];
  emptyDomain?: "preserve" | "require-explicit";
  range?: ScaleRange;
  nice?: boolean | LinearNiceCountOptions;
  zero?: boolean;
  clamp?: boolean;
  reverse?: boolean;
  base?: number;
  exponent?: number;
  constant?: number;
  paddingInner?: number;
  paddingOuter?: number;
  padding?: number;
  align?: number;
  palette?: Palette;
  interpolate?: ContinuousColorInterpolation;
  whitePoint?: "d65" | "d50";
  /** Finite Cubehelix lightness gamma, including zero and negative values. Defaults to 1. */
  gamma?: number;
  midpoint?: number | "auto";
  unknown?: unknown;
}

`ScaleRange`

Expand ScaleRange

export type ScaleRange = "auto" | readonly unknown[] | {
  readonly palette: Palette;
};

Related types: Palette.

`ScaleType`

Expand ScaleType

export type ScaleType =
  | "linear"
  | "log"
  | "pow"
  | "sqrt"
  | "symlog"
  | "time"
  | "band"
  | "point"
  | "ordinal"
  | "sequential"
  | "quantize"
  | "quantile"
  | "threshold";

`SecondaryPositionEncodingOptions`

Expand SecondaryPositionEncodingOptions

export type SecondaryPositionEncodingOptions =
  | SecondaryRulePositionEncodingOptions
  | { 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);

`SecondaryRulePositionEncodingOptions`

Expand SecondaryRulePositionEncodingOptions

type SecondaryRulePositionEncodingOptions = RulePositionEncodingBase & {
  scale?: { id?: string };
} & (
  | { fieldType: Exclude<FieldType, "temporal">; temporalUnit?: never }
  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit }
);

`SelectMarksOptions`

Expand SelectMarksOptions

export type SelectMarksOptions = {
  id?: string;
  target?: string;
} & MarkSelector;

Related types: MarkSelector.

`SeparateFilledLegendOptions`

Expand SeparateFilledLegendOptions

type SeparateFilledLegendOptions = DistributiveLegendOmit<Exclude<FilledMarkLegendOptions, { combine: "color-size" }>, "combine"> & { combine?: "separate" };

`SeriesLayoutOptions`

Expand SeriesLayoutOptions

export interface SeriesLayoutOptions { target?: string; mode: ColorLayout; }

Related types: ColorLayout.

`ShapeEncodingOptions`

Expand ShapeEncodingOptions

export type ShapeEncodingOptions = {
  field: string;
  target?: string;
  fieldType?: "nominal";
  scale?: ShapeScaleOptions;
};

Related types: ShapeScaleOptions.

`ShapeScaleOptions`

Expand ShapeScaleOptions

export type ShapeScaleOptions = ScaleFields<"id"> & {
  type?: "ordinal";
  domain?: "auto" | readonly unknown[];
  /** One entry per domain value; explicit repeated shapes are allowed. Auto uses distinct shapes. */
  range?: "auto" | readonly PointShape[];
  unknown?: PointShape;
};

Related types: ScaleFields · PointShape.

`SizeEncodingOptions`

Expand SizeEncodingOptions

export type SizeEncodingOptions =
  | { value: number; target?: string; field?: never; fieldType?: never; scale?: never }
  | ({
  value?: never;
  field: string;
  target?: string;
} & (
  | { fieldType?: "quantitative"; scale?: SizeScaleOptions }
  | { fieldType: "nominal" | "ordinal"; scale?: CategoricalSizeScaleOptions }
));

`SizeScaleCommonOptions`

Expand SizeScaleCommonOptions

type SizeScaleCommonOptions = ScaleFields<"id" | "reverse"> & {
  unknown?: number;
};

Related types: ScaleFields.

`SizeScaleOptions`

Expand SizeScaleOptions

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;
    });

`SizeScaleTypeEditPatch`

Expand SizeScaleTypeEditPatch

type SizeScaleTypeEditPatch =
  | (WithoutScaleId<CategoricalSizeScaleOptions> & { type: "ordinal" })
  | (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[]];
    });

`SortKey`

Expand SortKey

export interface SortKey {
  field: string;
  order?: "ascending" | "descending";
  nulls?: "first" | "last";
  temporalUnit?: "year" | "timestamp";
}

`SortedDataOptions`

Expand SortedDataOptions

export interface SortedDataOptions {
  id: string;
  source?: string;
  sortBy: readonly [SortKey, ...SortKey[]];
}

Related types: SortKey.

`SourceSchemaField`

Expand SourceSchemaField

export interface SourceSchemaField {
  /** Exact source row key, including an empty string or whitespace. */
  name: string;
  storageType: Exclude<DatasetStorageType, "unknown" | "mixed">;
  nullable?: boolean;
  optional?: boolean;
}

Related types: DatasetStorageType.

`SourceSchemaInput`

Expand SourceSchemaInput

export interface SourceSchemaInput {
  fields: readonly SourceSchemaField[];
}

Related types: SourceSchemaField.

`StackDataMode`

Expand StackDataMode

export type StackDataMode = "stack" | "fill" | "center" | "diverging";

`StackDataOptions`

Expand StackDataOptions

export interface StackDataOptions {
  id?: string;
  source?: string;
  category: string;
  group: string;
  value: string;
  mode?: StackDataMode;
  as?: StackDataOutputFields;
}

Related types: StackDataMode · StackDataOutputFields.

`StackDataOutputFields`

Expand StackDataOutputFields

export interface StackDataOutputFields {
  start?: string;
  end?: string;
  value?: string;
  share?: string;
}

`StackMode`

Expand StackMode

export type StackMode = "zero" | "normalize" | null;

`StatisticalWeight`

Expand StatisticalWeight

export interface StatisticalWeight {
  readonly field: string;
  readonly kind: "frequency" | "reliability";
}

`StoredCell`

Expand StoredCell

type StoredCell<T> = T extends (...args: never[]) => unknown ? never
  : T extends readonly (infer Value)[] ? readonly StoredCell<Value>[]
  : T extends object ? { readonly [Key in keyof T]: StoredCell<T[Key]> }
  : T;

`StripBandJitterOptions`

Expand StripBandJitterOptions

export interface StripBandJitterOptions {
  maxOffset: { pixels?: never; band: number };
  seed?: string | number;
  key?: string;
}

`StripCategoryChannel`

Expand StripCategoryChannel

export type StripCategoryChannel = string | {
  field: string;
  fieldType?: "nominal" | "ordinal";
  scale?: CategoricalPositionScaleOptions;
};

Related types: CategoricalPositionScaleOptions.

`StripPixelJitterOptions`

Expand StripPixelJitterOptions

export interface StripPixelJitterOptions {
  maxOffset: { pixels: number; band?: never };
  seed?: string | number;
  key?: string;
}

`StrokeDashEncodingOptions`

Expand StrokeDashEncodingOptions

export type StrokeDashEncodingOptions =
  | {
      field: string;
      value?: never;
      target?: string;
      fieldType?: "nominal" | "ordinal";
      scale?: DashScaleOptions;
    }
  | {
      value: DashStyle | DashPattern;
      field?: never;
      target?: string;
      fieldType?: never;
      scale?: never;
    };

Related types: DashScaleOptions · DashStyle · DashPattern.

`StrokeEncodingOptions`

Expand StrokeEncodingOptions

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";
      };
    };

`StrokeStyleDetails`

Expand StrokeStyleDetails

export type StrokeStyleDetails = {
  lineCap?: "butt" | "round" | "square";
  lineJoin?: "miter" | "round" | "bevel";
  miterLimit?: number;
};

`StrokeWidthEncodingOptions`

Expand StrokeWidthEncodingOptions

export type StrokeWidthEncodingOptions =
  | {
      value: number;
      field?: never;
      target?: string;
      fieldType?: never;
      scale?: never;
    }
  | {
      field: string;
      value?: never;
      target?: string;
      fieldType?: "quantitative";
      scale?: StrokeWidthScaleOptions;
    };

/** Constant value and scale ranges are graphical areas in square pixels. */

Related types: StrokeWidthScaleOptions.

`StrokeWidthScaleOptions`

Expand StrokeWidthScaleOptions

export type StrokeWidthScaleOptions = NonPointQuantitativePositionScaleOptions extends infer T
  ? T extends unknown ? Omit<T, "nice"> & { nice?: boolean } : never
  : never;

`SummaryAggregateOptions`

Expand SummaryAggregateOptions

export interface SummaryAggregateOptions {
  op: AggregateOperation | { op: "ciLower" | "ciUpper"; method: BootstrapMeanIntervalMethod; level?: number };
  field?: string;
  as: string;
}

`SummaryDataOptions`

Expand SummaryDataOptions

export interface SummaryDataOptions {
  id: string;
  source?: string;
  groupBy?: string | readonly string[];
  aggregates: readonly SummaryAggregateOptions[];
  members?: string;
  weight?: StatisticalWeight;
  missing?: "error" | "drop";
  empty?: "null" | "identity";
}

Related types: SummaryAggregateOptions · StatisticalWeight.

`TemporalBindingBranch`

Expand TemporalBindingBranch

type TemporalBindingBranch =
  | { fieldType?: "quantitative"; temporalUnit?: never }
  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit };

Related types: TemporalInputUnit.

`TemporalInputUnit`

Expand TemporalInputUnit

export type TemporalInputUnit = "auto" | "year" | "timestamp";

`TemporalPositionScaleOptions`

Expand TemporalPositionScaleOptions

export type TemporalPositionScaleOptions =
  NonPointTemporalPositionScaleOptions & { unknown?: number };

`TextEncodingOptions`

Expand TextEncodingOptions

export type TextEncodingOptions = {
  target?: string;
  format?: TextFormat;
} & (
  | { 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. */

Related types: TextFormat.

`TextFormat`

Expand TextFormat

export type TextFormat = ValueFormat;

Related types: ValueFormat.

`TextMarkOptions`

Expand TextMarkOptions

export interface TextMarkOptions {
  clip?: boolean;
  /** Logical-pixel baseline spacing; defaults to 1.2 times fontSize. */
  lineHeight?: number;
  /** Anchor the first line or center the complete multiline block. */
  blockAlign?: "first" | "middle";
  /** Follow resolved source appearance; an explicit fill takes precedence. Source-owned labels only. */
  inheritColor?: "fill" | "stroke" | false;
  id?: string;
  data?: string;
  /** Explicit source mark. Mutually exclusive with data; may be incomplete. */
  source?: string;
  text?: unknown;
  missing?: "error" | "skip";
  fill?: string;
  opacity?: number;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
  align?: "left" | "right" | "center" | "start" | "end";
  baseline?: "top" | "hanging" | "middle" | "alphabetic" | "ideographic" | "bottom";
  rotation?: RotationInput;
  dx?: number;
  dy?: number;
}

Related types: RotationInput.

`TextMeasurement`

Expand TextMeasurement

export interface TextMeasurement {
  readonly text: string;
  readonly fontFamily: string;
  readonly fontSize: number;
  readonly fontWeight: TextMetricFontWeight;
  readonly fontStyle?: "normal" | "italic";
  readonly width: number;
}

Related types: TextMetricFontWeight.

`TextMetricFontWeight`

Expand TextMetricFontWeight

export type TextMetricFontWeight = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;

`TextMetricsProfile`

Expand TextMetricsProfile

export interface TextMetricsProfile {
  readonly schemaVersion: 1;
  readonly id: string;
  readonly measurements: readonly TextMeasurement[];
}

Related types: TextMeasurement.

`TextOffsetEncodingOptions`

Expand TextOffsetEncodingOptions

export type TextOffsetEncodingOptions =
  | { target?: string; value: number; field?: never }
  | { target?: string; field: string; value?: never };

`TextPlotPositionChannel`

Expand TextPlotPositionChannel

type TextPlotPositionChannel =
  | string
  | ({ field: string } & PositionScaleBranches<
      NonPointQuantitativePositionScaleOptions,
      NonPointTemporalPositionScaleOptions,
      NonPointCategoricalPositionScaleOptions>)
  | WithoutEncodingTarget<Extract<DatumPositionEncodingOptions, { datum: unknown }>> & { coordinate?: never };

`ThemeDefinition`

Expand ThemeDefinition

export type ThemeDefinition =
  | ThemeName
  | { base: ThemeName; tokens: Partial<ThemeTokens> };

Related types: ThemeName · ThemeTokens.

`ThemeName`

Expand ThemeName

export type ThemeName = "light" | "dark";

`ThemeTokens`

Expand ThemeTokens

export interface ThemeTokens {
  axisLabel?: string;
  axisLabelFontFamily?: string;
  axisTitleFontFamily?: string;
  axisLabelFontSize?: number;
  axisTitleFontSize?: number;
  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;
}

`ThetaAxisLabelOptions`

Expand ThetaAxisLabelOptions

export type ThetaAxisLabelOptions = PolarLabelOptions & DisplayLabelOptions;

Related types: PolarLabelOptions · DisplayLabelOptions.

`ThetaEncodingOptions`

Expand 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;
  scale?: ThetaScaleOptions;
  coordinate?: string;
  aggregate?: "count" | "sum";
  weight?: string;
} & (
  | { fieldType?: Exclude<FieldType, "temporal">; temporalUnit?: never }
  | { fieldType: "temporal"; temporalUnit?: TemporalInputUnit }
);

Related types: ThetaScaleOptions · FieldType · TemporalInputUnit.

`ThetaScaleOptions`

Expand ThetaScaleOptions

export interface ThetaScaleOptions {
  id?: string;
  type?: "linear" | "time" | "band" | "point";
  domain?: "auto" | readonly unknown[];
  range?: "auto" | readonly [number, number];
  nice?: boolean;
  zero?: boolean;
  clamp?: boolean;
  reverse?: boolean;
  paddingInner?: number;
  paddingOuter?: number;
  padding?: number;
  align?: number;
}

`ThetaTicksAndLabelsOptions`

Expand ThetaTicksAndLabelsOptions

export interface ThetaTicksAndLabelsOptions
  extends Omit<PolarTicksAndLabelsOptions, "labels"> {
  labels?: AxisLabelStyleOptions & DisplayLabelOptions;
}

`ThresholdColorScaleOptions`

Expand ThresholdColorScaleOptions

export type ThresholdColorScaleOptions =
  NonPointThresholdColorScaleOptions & { unknown?: string };

Related types: NonPointThresholdColorScaleOptions.

`TimeAxisDirective`

Expand TimeAxisDirective

type TimeAxisDirective = "Y" | "m" | "d" | "b" | "a" | "H" | "M" | "S" | "L";

`TimeUnit`

Expand TimeUnit

export type TimeUnit =
  | "year"
  | "quarter"
  | "month"
  | "day"
  | "hour"
  | "minute"
  | "second"
  | "week"
  | "weekday";

`TimeUnitDataBaseOptions`

Expand TimeUnitDataBaseOptions

type TimeUnitDataBaseOptions = {
  /** Preserve null or absent inputs as null buckets; defaults to strict errors. */
  missing?: "error" | "null";
  id: string;
  source?: string;
  field: string;
  temporalUnit?: TemporalInputUnit;
  /** Defaults to `${field}_${unit}`; collisions are rejected. */
  as?: string;
  timeZone?: string;
};

Related types: TemporalInputUnit.

`TimeUnitDataOptions`

Expand TimeUnitDataOptions

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;
    }
);

Related types: TimeUnitDataBaseOptions · TimeUnit.

`TitleOptions`

Expand TitleOptions

export interface TitleOptions {
  /** Explicit hard lines are retained; blank lines reserve spacing without painted text. */
  text: string;
  /** Multiline subtitle with at least one non-empty hard line. */
  subtitle?: string;
  position?: "top" | "bottom" | "left" | "right";
  align?: "left" | "center" | "right";
  offset?: number;
  /** Signed logical-pixel shift along the selected edge; defaults to zero. */
  alongOffset?: number;
  gap?: number;
  maxWidth?: number;
  wrap?: "word" | "character";
  lineHeight?: number;
  /** Subtitle-only line spacing; overrides lineHeight without requiring maxWidth. */
  subtitleLineHeight?: number;
  titleStyle?: TitleTextStyleOptions;
  subtitleStyle?: TitleTextStyleOptions;
}

Related types: TitleTextStyleOptions.

`TitleTextStyleOptions`

Expand TitleTextStyleOptions

export interface TitleTextStyleOptions {
  fontStyle?: "normal" | "italic";
  color?: string;
  fontSize?: number;
  fontFamily?: string;
  fontWeight?: string | number;
}

`UtcFormatString`

Expand UtcFormatString

export type UtcFormatString = `${string}%${TimeAxisDirective}${string}`;

Related types: TimeAxisDirective.

`ValueFormat`

Expand ValueFormat

export type ValueFormat = "auto" | NumericFormatString | UtcFormatString;

Related types: NumericFormatString · UtcFormatString.

`ValueFormatDigit`

Expand ValueFormatDigit

type ValueFormatDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

`ValueFormatPrecision`

Expand ValueFormatPrecision

type ValueFormatPrecision = ValueFormatDigit | 10 | 11 | 12 | `0${ValueFormatDigit}`;

Related types: ValueFormatDigit.

`ViolinPlotAreaOptions`

Expand ViolinPlotAreaOptions

export interface ViolinPlotAreaOptions extends StrokeStyleDetails {
  fill?: FillPaint;
  opacity?: number;
  stroke?: string;
  strokeWidth?: number;
  curve?: CurveInterpolation;
}

Related types: StrokeStyleDetails · FillPaint · CurveInterpolation.

`ViolinPlotColorOptions`

Expand ViolinPlotColorOptions

export type ViolinPlotColorOptions =
  | string
  | {
      field: string;
      fieldType?: "nominal" | "ordinal";
      scale?: NonPointCategoricalColorScaleOptions;
      palette?: Palette;
      layout?: "overlay";
    };

`ViolinPlotDensityOptions`

Expand ViolinPlotDensityOptions

export interface ViolinPlotDensityOptions
  extends GradientPlotDensityOptions {
  weight?: StatisticalWeight;
  width?: DensityPlacementWidth;
  side?: "both" | "left" | "right" | "top" | "bottom";
}

`ViolinPlotOptions`

Expand ViolinPlotOptions

export interface ViolinPlotOptions {
  id?: string;
  data?: string;
  coordinate?: string;
  x: ViolinPlotPositionChannel;
  y: ViolinPlotPositionChannel;
  split?: ViolinPlotSplitOptions;
  color?: ViolinPlotColorOptions;
  density?: ViolinPlotDensityOptions;
  area?: ViolinPlotAreaOptions;
  guides?: false | CartesianCategoricalGuideOptions;
}

`ViolinPlotPositionChannel`

Expand ViolinPlotPositionChannel

export type ViolinPlotPositionChannel =
  | string
  | {
      field: string;
      fieldType: "nominal" | "ordinal";
      scale?: NonPointBandPositionScaleOptions;
    }
  | {
      field: string;
      fieldType: "quantitative";
      scale?: NonPointQuantitativePositionScaleOptions;
    }
  | {
      field: string;
      fieldType?: undefined;
      scale?:
        | NonPointBandPositionScaleOptions
        | NonPointQuantitativePositionScaleOptions;
    };

`ViolinPlotSplitOptions`

Expand ViolinPlotSplitOptions

export interface ViolinPlotSplitOptions {
  field: string;
  domain?: readonly [unknown, unknown];
}

`WindowDataOptions`

Expand WindowDataOptions

export interface WindowDataOptions {
  id: string;
  source?: string;
  partitionBy?: string | readonly string[];
  sortBy?: readonly WindowSort[];
  operations: readonly WindowOperation[];
  temporalUnit?: TemporalInputUnit;
}

Related types: WindowSort · WindowOperation · TemporalInputUnit.

`WindowFrame`

Expand WindowFrame

export type WindowFrame = RowWindowFrame | DurationWindowFrame;

Related types: RowWindowFrame · DurationWindowFrame.

`WindowOperation`

Expand WindowOperation

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;
    }
  | {
      op: "movingMean" | "movingSum";
      field: string;
      as: string;
      frame: WindowFrame;
      minPeriods?: number;
      missing?: "error" | "skip";
    };

Related types: WindowFrame.

`WindowSort`

Expand WindowSort

export interface WindowSort {
  field: string;
  order?: WindowSortOrder;
}

Related types: WindowSortOrder.

`WindowSortOrder`

Expand WindowSortOrder

export type WindowSortOrder = "ascending" | "descending";

`WithoutEncodingTarget`

Expand WithoutEncodingTarget

type WithoutEncodingTarget<T> = T extends unknown
  ? Omit<T, "target" | "coordinate">
  : never;

`WithoutScaleId`

Expand WithoutScaleId

type WithoutScaleId<T> = T extends unknown ? Omit<T, "id"> : never;

`WithoutScaleSelection`

Expand WithoutScaleSelection

type WithoutScaleSelection<T> = T extends unknown ? Omit<T, "id" | "target"> : never;

`XAxisPosition`

Expand XAxisPosition

export type XAxisPosition = "bottom" | "top";

`XOffsetEncodingOptions`

Expand XOffsetEncodingOptions

export interface XOffsetEncodingOptions extends OffsetEncodingOptions {}

Related types: OffsetEncodingOptions.

`YAxisPosition`

Expand YAxisPosition

export type YAxisPosition = "left" | "right";

`YOffsetEncodingOptions`

Expand YOffsetEncodingOptions

export interface YOffsetEncodingOptions extends OffsetEncodingOptions {}

Related types: OffsetEncodingOptions.

`YPositionEncodingOptions`

Expand YPositionEncodingOptions

export type YPositionEncodingOptions =
  PositionEncodingOptions extends infer T
    ? T extends unknown ? Omit<T, "bin" | "stack"> & { stack?: YStackMode } : never
    : never;

Related types: PositionEncodingOptions · YStackMode.

`YStackMode`

Expand YStackMode

export type YStackMode = StackMode | "center";

Related types: StackMode.

`ZeroSupportingPositionScaleType`

Expand ZeroSupportingPositionScaleType

export type ZeroSupportingPositionScaleType =
  | "linear" | "pow" | "sqrt" | "symlog";

Action Reference · Extension Actions

Documentation provenance

293 actions · sha256:e755591a2e5f5e2b494867583876e28020a478c5220b77bdc6ad469a6224891d