Pivot Charts

Module Extensions

`HTMLRevoGridElement` (Extended from `global`)

1
interface HTMLRevoGridElement {
2
  /**
3
       * Renderer, complete-data provider, defaults, and safety limits for
4
       * renderer-neutral Pivot Charts.
5
       */
6
      pivotCharts?: PivotChartsConfig;
7
  /**
8
       * Optional modeless-dialog and context-menu integration for Pivot Charts.
9
       */
10
      pivotChartsUi?: PivotChartsUiConfig
11
}

`HTMLRevoGridElementEventMap` (Extended from `global`)

1
interface HTMLRevoGridElementEventMap {
2
  'pivot-chart-created': PivotChartCreatedEventDetail;
3
  'pivot-chart-updated': PivotChartUpdatedEventDetail;
4
  'pivot-chart-destroyed': PivotChartDestroyedEventDetail;
5
  'pivot-chart-node-click': PivotChartNodeClickEventDetail;
6
  'pivot-chart-error': PivotChartErrorEventDetail;
7
  'pivot-chart-before-drill': PivotChartDrillEventDetail;
8
  'pivot-chart-drill-start': PivotChartDrillEventDetail;
9
  'pivot-chart-drilled': PivotChartDrilledEventDetail;
10
  'pivot-chart-drill-error': PivotChartDrillErrorEventDetail;
11
  'pivot-chart-drill-reset': PivotChartDrilledEventDetail;
12
  'pivot-chart-drill-sync': PivotChartDrillSyncEventDetail
13
}

Plugin API

`toPivotChartError`

1
export function toPivotChartError(
2
  error: unknown,
3
  fallbackCode: PivotChartErrorCode = 'CHART_UPDATE_FAILED',
4
);

`PivotChartErrorCode`

1
export type PivotChartErrorCode =
2
  | 'PIVOT_NOT_ACTIVE'
3
  | 'RENDERER_REQUIRED'
4
  | 'UNSUPPORTED_CHART_TYPE'
5
  | 'INVALID_DATA_SHAPE'
6
  | 'INVALID_SERIES_SELECTION'
7
  | 'LIMIT_EXCEEDED'
8
  | 'SERVER_PROVIDER_REQUIRED'
9
  | 'SERVER_RESPONSE_INCOMPLETE'
10
  | 'CAPABILITY_UNAVAILABLE'
11
  | 'CHART_ID_CONFLICT'
12
  | 'CHART_UPDATE_FAILED';

`PivotChartError`

1
class PivotChartError {}

`PIVOT_CHART_CREATED_EVENT`

1
PIVOT_CHART_CREATED_EVENT: string;

`PIVOT_CHART_UPDATED_EVENT`

1
PIVOT_CHART_UPDATED_EVENT: string;

`PIVOT_CHART_DESTROYED_EVENT`

1
PIVOT_CHART_DESTROYED_EVENT: string;

`PIVOT_CHART_NODE_CLICK_EVENT`

1
PIVOT_CHART_NODE_CLICK_EVENT: string;

`PIVOT_CHART_ERROR_EVENT`

1
PIVOT_CHART_ERROR_EVENT: string;

`PIVOT_CHART_BEFORE_DRILL_EVENT`

1
PIVOT_CHART_BEFORE_DRILL_EVENT: string;

`PIVOT_CHART_DRILL_START_EVENT`

1
PIVOT_CHART_DRILL_START_EVENT: string;

`PIVOT_CHART_DRILLED_EVENT`

1
PIVOT_CHART_DRILLED_EVENT: string;

`PIVOT_CHART_DRILL_ERROR_EVENT`

1
PIVOT_CHART_DRILL_ERROR_EVENT: string;

`PIVOT_CHART_DRILL_RESET_EVENT`

1
PIVOT_CHART_DRILL_RESET_EVENT: string;

`PIVOT_CHART_DRILL_SYNC_EVENT`

1
PIVOT_CHART_DRILL_SYNC_EVENT: string;

`createPivotChartAnalyticalFrame`

Produces the renderer-neutral, tidy analytical frame for a projected Pivot dataset. Each matrix cell becomes one observation with stable category, series, and measure field IDs.

1
export function createPivotChartAnalyticalFrame(
2
  dataset: Pick<
3
    PivotChartDataset,
4
    'categories' | 'series' | 'values' | 'displayValues' | 'hierarchies'
5
  >,
6
  labels:;

`ensurePivotChartAnalyticalFrame`

1
export function ensurePivotChartAnalyticalFrame(
2
  dataset: PivotChartDataset,
3
): PivotChartDataset;

`PIVOT_CHART_CATEGORY_FIELD_ID`

1
PIVOT_CHART_CATEGORY_FIELD_ID: string;

`PIVOT_CHART_SERIES_FIELD_ID`

1
PIVOT_CHART_SERIES_FIELD_ID: string;

`getPivotChartDefinition`

1
export function getPivotChartDefinition(
2
  chartType: PivotChartType,
3
): PivotChartDefinition<PivotChartType>;

`PivotChartFamily`

1
export type PivotChartFamily =
2
  | 'column'
3
  | 'bar'
4
  | 'line'
5
  | 'area'
6
  | 'partToWhole'
7
  | 'relationship'
8
  | 'hierarchical'
9
  | 'combination'
10
  | 'statistical'
11
  | 'specialized'
12
  | 'kpi'
13
  | 'polar'
14
  | 'distribution'
15
  | 'matrix'
16
  | 'process'
17
  | 'flow'
18
  | 'financial';

`PivotChartDataChannel`

1
export type PivotChartDataChannel =
2
  | 'category'
3
  | 'series'
4
  | 'value'
5
  | 'x'
6
  | 'y'
7
  | 'size'
8
  | 'hierarchy'
9
  | 'weight'
10
  | 'source'
11
  | 'target'
12
  | 'start'
13
  | 'end'
14
  | 'low'
15
  | 'high'
16
  | 'open'
17
  | 'close'
18
  | 'volume'
19
  | 'actual'
20
  | 'target'
21
  | 'variance'
22
  | 'color'
23
  | 'shape'
24
  | 'angle'
25
  | 'radius'
26
  | 'parent'
27
  | 'child'
28
  | 'facetRow'
29
  | 'facetColumn'
30
  | 'label'
31
  | 'tooltip';

`PivotChartChannelRequirement`

1
interface PivotChartChannelRequirement {
2
  channel: PivotChartDataChannel;
3
  min: number;
4
  max?: number
5
}

`PivotChartDefinition`

1
interface PivotChartDefinition {
2
  type: TType;
3
  localization: {
4
      labelKey: TType;
5
      descriptionKey: TType;
6
    };
7
  family: PivotChartFamily;
8
  order: number;
9
  dataView:
10
      | 'matrix'
11
      | 'xy'
12
      | 'hierarchy'
13
      | 'binned'
14
      | 'distribution'
15
      | 'statistical'
16
      | 'range'
17
      | 'flow'
18
      | 'financial'
19
      | 'kpi'
20
      | 'calendar';
21
  channels: readonly PivotChartChannelRequirement[];
22
  constraints: {
23
      nonNegative: boolean;
24
      rowHierarchy: boolean;
25
      seriesSelection: 'all' | 'firstAvailable';
26
    };
27
  interactions: {
28
      drill: boolean;
29
      selection: boolean;
30
      zoom: boolean;
31
      pan: boolean;
32
      labels: boolean;
33
      stacking: boolean;
34
    };
35
  presentation: {
36
      axes: boolean;
37
      legend: 'series' | 'category' | 'none';
38
    };
39
  preview: {
40
      dataset: PivotChartDataset;
41
      bindings: PivotChartBindings;
42
      presentation: PivotChartPresentation;
43
      aspectRatio: number;
44
    };
45
  options: PivotChartOptionsSchema;
46
  renderer: PivotChartRenderFunction;
47
  documentationSlug: string
48
}

`PIVOT_CHART_DEFINITIONS`

1
PIVOT_CHART_DEFINITIONS: readonly [PivotChartDefinition<"groupedColumn">, PivotChartDefinition<"stackedColumn">, PivotChartDefinition<"normalizedColumn">, PivotChartDefinition<"groupedBar">, PivotChartDefinition<"stackedBar">, PivotChartDefinition<"normalizedBar">, PivotChartDefinition<"line">, PivotChartDefinition<"smoothLine">, PivotChartDefinition<"steppedLine">, PivotChartDefinition<"area">, PivotChartDefinition<"steppedArea">, PivotChartDefinition<"stackedArea">, PivotChartDefinition<"normalizedArea">, PivotChartDefinition<"pie">, PivotChartDefinition<"donut">, PivotChartDefinition<"treemap">, PivotChartDefinition<"sunburst">, PivotChartDefinition<"scatter">, PivotChartDefinition<"bubble">, PivotChartDefinition<"columnLine">, PivotChartDefinition<"areaLine">, PivotChartDefinition<"rangeColumn">, PivotChartDefinition<"rangeBar">, PivotChartDefinition<"rangeArea">, PivotChartDefinition<"confidenceBand">, PivotChartDefinition<"errorInterval">, PivotChartDefinition<"waterfall">, PivotChartDefinition<"lollipop">, PivotChartDefinition<"bullet">, PivotChartDefinition<"semiDonut">, PivotChartDefinition<"rose">, PivotChartDefinition<"radarLine">, PivotChartDefinition<"radarArea">, PivotChartDefinition<"polarColumn">, PivotChartDefinition<"stackedPolarColumn">, PivotChartDefinition<"normalizedPolarColumn">, PivotChartDefinition<"radialBar">, PivotChartDefinition<"multiRingRadialBar">, PivotChartDefinition<"histogram">, PivotChartDefinition<"stripDot">, PivotChartDefinition<"heatmap">, PivotChartDefinition<"calendarHeatmap">, PivotChartDefinition<"densityScatter">, PivotChartDefinition<"icicle">, PivotChartDefinition<"circlePacking">, PivotChartDefinition<"funnel">, PivotChartDefinition<"pyramid">, PivotChartDefinition<"boxPlot">, PivotChartDefinition<"violin">, PivotChartDefinition<"rangeInterval">, PivotChartDefinition<"sankey">, PivotChartDefinition<"chord">, PivotChartDefinition<"candlestick">, PivotChartDefinition<"ohlc">, PivotChartDefinition<"volumePrice">, PivotChartDefinition<"gauge">, PivotChartDefinition<"kpi">, PivotChartDefinition<"progressGauge">, PivotChartDefinition<"connectedScatter">, PivotChartDefinition<"waffle">, PivotChartDefinition<"smallMultiples">, PivotChartDefinition<"annotatedTimeSeries">, PivotChartDefinition<"timelineRange">];

`PivotChartType`

1
export type PivotChartType =
2
  typeof PIVOT_CHART_DEFINITIONS[number]['type'];

`PIVOT_CHART_TYPES`

1
PIVOT_CHART_TYPES: readonly ("line" | "area" | "kpi" | "groupedColumn" | "stackedColumn" | "normalizedColumn" | "groupedBar" | "stackedBar" | "normalizedBar" | "smoothLine" | "steppedLine" | "steppedArea" | "stackedArea" | "normalizedArea" | "pie" | "donut" | "treemap" | "sunburst" | "scatter" | "bubble" | "densityScatter" | "connectedScatter" | "columnLine" | "areaLine" | "rangeColumn" | "rangeBar" | "rangeArea" | "confidenceBand" | "errorInterval" | "waterfall" | "lollipop" | "bullet" | "semiDonut" | "rose" | "radarLine" | "radarArea" | "polarColumn" | "stackedPolarColumn" | "normalizedPolarColumn" | "radialBar" | "multiRingRadialBar" | "histogram" | "stripDot" | "heatmap" | "calendarHeatmap" | "icicle" | "circlePacking" | "funnel" | "pyramid" | "boxPlot" | "violin" | "rangeInterval" | "sankey" | "chord" | "candlestick" | "ohlc" | "volumePrice" | "gauge" | "progressGauge" | "waffle" | "smallMultiples" | "annotatedTimeSeries" | "timelineRange")[];

`getPivotChartCatalogExtensionDefinitions`

Resolves definitions for a standalone geographic capability host.

Geographic types are intentionally not accepted by PivotChartModel or the built-in Pivot Charts gallery/renderer. Applications render them explicitly through pack.render(...), which keeps provider assets and asynchronous map projection outside the core plugin lifecycle.

1
export function getPivotChartCatalogExtensionDefinitions(
2
  pack?: PivotChartGeographicCapabilityPack,
3
): readonly PivotChartCatalogExtensionDefinition[];

`PivotChartCatalogExtensionDefinition`

1
export type PivotChartCatalogExtensionDefinition =
2
  PivotChartGeographicDefinition;

`evaluatePivotChartCatalog`

1
export function evaluatePivotChartCatalog(
2
  context: PivotChartCompatibilityContext,
3
): PivotChartCompatibility[];

`evaluatePivotChartCompatibility`

1
export function evaluatePivotChartCompatibility(
2
  chartType: PivotChartType,
3
  context: PivotChartCompatibilityContext,
4
): PivotChartCompatibility;

`resolveRelationshipBindings`

1
export function resolveRelationshipBindings(
2
  channels: readonly Extract<PivotChartBindingChannel, 'x' | 'y' | 'size'>[],
3
  dataset: PivotChartDataset,
4
  current: PivotChartBindings,
5
  rebindWhenIncomplete = false,
6
): PivotChartBindings | undefined;

`PivotChartCompatibilityStatus`

1
export type PivotChartCompatibilityStatus =
2
  | 'recommended'
3
  | 'compatible'
4
  | 'needsFields'
5
  | 'unsupported';

`PivotChartCompatibilityReason`

1
export type PivotChartCompatibilityReason =
2
  | { code: 'rendererUnsupported' }
3
  | { code: 'categoriesRequired'; minimum: number }
4
  | { code: 'seriesRequired'; minimum: number }
5
  | { code: 'seriesLimit'; maximum: number }
6
  | { code: 'singleSeriesRequired' }
7
  | { code: 'rowHierarchyRequired' }
8
  | { code: 'dateCategoriesRequired' }
9
  | { code: 'distributionViewRequired' }
10
  | { code: 'nonNegativeValuesRequired' }
11
  | {
12
      code: 'channelRequired';
13
      channel: Extract<
14
        PivotChartBindingChannel,
15
        | 'x'
16
        | 'y'
17
        | 'size'
18
        | SpecializedSeriesChannel
19
        | 'source'
20
        | 'target'
21
        | 'weight'
22
      >;
23
    }
24
  | { code: 'noCompletePoints' }
25
  | { code: 'nonNegativeSizeRequired' };

`PivotChartCompatibility`

1
interface PivotChartCompatibility {
2
  chartType: PivotChartType;
3
  status: PivotChartCompatibilityStatus;
4
  reasons: readonly PivotChartCompatibilityReason[];
5
  score: number;
6
  inferredPatch?: PivotChartUpdatePatch
7
}

`PivotChartCompatibilityContext`

1
interface PivotChartCompatibilityContext {
2
  dataset?: PivotChartDataset;
3
  model: PivotChartModel;
4
  supportedTypes: readonly PivotChartType[]
5
}

`createInitialRowDrillState`

1
export function createInitialRowDrillState(
2
  scope: PivotChartInitialScope,
3
  revision: number | null = null,
4
): PivotChartDrillState;

`canDrillIntoCategory`

1
export function canDrillIntoCategory(category: PivotChartCategory);

`canDrillIntoSeries`

1
export function canDrillIntoSeries(series: PivotChartSeries);

`canDrillIntoTarget`

1
export function canDrillIntoTarget(target: PivotChartDrillTarget);

`createRowDrillFrame`

1
export function createRowDrillFrame(
2
  category: PivotChartCategory,
3
): PivotChartDrillFrame;

`appendRowDrillFrame`

1
export function appendRowDrillFrame(
2
  state: PivotChartDrillState,
3
  category: PivotChartCategory,
4
  revision: number,
5
): PivotChartDrillState;

`appendDrillFrame`

1
export function appendDrillFrame(
2
  state: PivotChartDrillState,
3
  target: PivotChartDrillTarget,
4
  revision: number,
5
): PivotChartDrillState;

`drillToFrame`

1
export function drillToFrame(
2
  state: PivotChartDrillState,
3
  frameIndex: number,
4
  revision: number,
5
): PivotChartDrillState;

`getParentDrillState`

1
export function getParentDrillState(
2
  state: PivotChartDrillState,
3
  revision: number,
4
);

`reconcileDrillState`

1
export function reconcileDrillState(
2
  state: PivotChartDrillState,
3
  pathDepth: number,
4
  revision: number,
5
);

`createRootPivotChartDrillState`

1
export function createRootPivotChartDrillState(
2
  revision: number | null = null,
3
): PivotChartDrillState;

`parsePivotChartModel`

Parses untrusted JSON into a validated, deeply owned V2 model.

1
export function parsePivotChartModel(input: unknown): PivotChartModel;

`clonePivotChartModel`

1
export function clonePivotChartModel(model: PivotChartModel): PivotChartModel;

`createPivotChartOptionsSchema`

1
export function createPivotChartOptionsSchema(;

`parsePivotChartOptions`

1
export function parsePivotChartOptions(
2
  value: unknown,
3
  schema: PivotChartOptionsSchema,
4
): PivotChartOptions;

`resolvePivotChartOption`

1
export function resolvePivotChartOption(
2
  options: PivotChartOptions | undefined,
3
  schema: PivotChartOptionsSchema,
4
  key: PivotChartOptionKey,
5
): PivotChartJsonValue | undefined;

`PivotChartOptionKey`

1
export type PivotChartOptionKey =
2
  | 'showGridLines'
3
  | 'markOpacity'
4
  | 'strokeWidth'
5
  | 'fillOpacity';

`PivotChartBooleanOptionDefinition`

1
interface PivotChartBooleanOptionDefinition {
2
  key: PivotChartOptionKey;
3
  control: 'boolean';
4
  defaultValue: boolean
5
}

`PivotChartRangeOptionDefinition`

1
interface PivotChartRangeOptionDefinition {
2
  key: PivotChartOptionKey;
3
  control: 'range';
4
  defaultValue: number;
5
  min: number;
6
  max: number;
7
  step: number
8
}

`PivotChartOptionDefinition`

1
export type PivotChartOptionDefinition =
2
  | PivotChartBooleanOptionDefinition
3
  | PivotChartRangeOptionDefinition;

`PivotChartOptionsSchema`

1
interface PivotChartOptionsSchema {
2
  fields: readonly PivotChartOptionDefinition[];
3
  defaults: Readonly<PivotChartOptions>
4
}

`projectPivotChartDataset`

1
export function projectPivotChartDataset(
2
  snapshot: PivotRuntimeSnapshot,
3
  context: PivotChartProjectorContext,
4
  options: PivotChartDataOptions =;

`projectPivotChartSemanticSlice`

Projects one already-aggregated semantic child slice through the same matrix adapter as the root chart. The Pivot query owns hierarchy navigation; this adapter only maps its committed rows into renderer data.

1
export function projectPivotChartSemanticSlice(
2
  snapshot: PivotRuntimeSnapshot,
3
  slice: PivotSemanticSlice,
4
  context: Omit<PivotChartProjectorContext, 'visibleRows'>,
5
  options: PivotChartDataOptions =;

`PIVOT_CHART_MODEL_VERSION`

1
PIVOT_CHART_MODEL_VERSION: 2;

`PivotChartTotalsMode`

1
export type PivotChartTotalsMode = 'none' | 'grand' | 'subtotals' | 'all';

`PivotChartTheme`

1
export type PivotChartTheme = 'auto' | string;

`PivotChartUpdateReason`

1
export type PivotChartUpdateReason =
2
  | 'data'
3
  | 'options'
4
  | 'theme'
5
  | 'relink'
6
  | 'drill';

`PivotChartLegendPosition`

1
export type PivotChartLegendPosition = 'top' | 'right' | 'bottom' | 'left' | 'none';

`PivotChartAxis`

1
export type PivotChartAxis = 'row' | 'column';

`PivotChartDrillSyncMode`

1
export type PivotChartDrillSyncMode = 'chart' | 'pivot' | 'both' | 'event';

`PivotChartLimits`

1
interface PivotChartLimits {
2
  maxCategories: number;
3
  maxSeries: number;
4
  maxDataPoints: number
5
}

`DEFAULT_PIVOT_CHART_LIMITS`

1
DEFAULT_PIVOT_CHART_LIMITS: Readonly<PivotChartLimits>;

`PivotChartMeasure`

1
interface PivotChartMeasure {
2
  prop: ColumnProp;
3
  aggregator: string;
4
  label: string
5
}

`PivotChartMeasureSelection`

1
export type PivotChartMeasureSelection = Pick<
2
  PivotChartMeasure,
3
  'prop' | 'aggregator'
4
>;

`PivotChartMemberKind`

1
export type PivotChartMemberKind =
2
  | 'leaf'
3
  | 'group'
4
  | 'subtotal'
5
  | 'grandTotal'
6
  | 'collapsed';

`PivotChartHierarchyLevel`

1
interface PivotChartHierarchyLevel {
2
  id: string;
3
  field: ColumnProp;
4
  label: string;
5
  index: number
6
}

`PivotChartHierarchyDefinition`

1
interface PivotChartHierarchyDefinition {
2
  id: string;
3
  axis: PivotChartAxis;
4
  levels: PivotChartHierarchyLevel[]
5
}

`PivotChartMemberHierarchy`

1
interface PivotChartMemberHierarchy {
2
  axis: PivotChartAxis;
3
  hierarchyId: string;
4
  levelId: string;
5
  levelIndex: number;
6
  maxLevelIndex: number;
7
  hasChildren: boolean;
8
  childCount?: number
9
}

`PivotChartCategory`

1
interface PivotChartCategory {
2
  id: string;
3
  label: string;
4
  path: PivotPath;
5
  labels: string[];
6
  depth: number;
7
  kind: PivotChartMemberKind;
8
  measure?: PivotChartMeasure;
9
  /** Optional row-axis hierarchy metadata used by drill-aware datasets. */
10
    hierarchy?: PivotChartMemberHierarchy
11
}

`PivotChartSeries`

1
interface PivotChartSeries {
2
  id: string;
3
  label: string;
4
  columnPath: PivotPath;
5
  labels: string[];
6
  kind: PivotChartMemberKind;
7
  prop: ColumnProp;
8
  /** Fixed measure for values-on-columns layouts; the category owns it for values-on-rows. */
9
    measure?: PivotChartMeasure;
10
  /** Optional column-axis hierarchy metadata used by drill-aware datasets. */
11
    hierarchy?: PivotChartMemberHierarchy
12
}

`PivotChartDataset`

1
interface PivotChartDataset {
2
  revision: number;
3
  source: 'client' | 'server';
4
  categories: PivotChartCategory[];
5
  series: PivotChartSeries[];
6
  /** Row-major matrix: values[categoryIndex][seriesIndex]. */
7
    values: Array<Array<number | null>>;
8
  /** Optional row-major strings for labels and tooltips. */
9
    displayValues?: Array<Array<string | null>>;
10
  /** Ordered hierarchy definitions supplied by drill-aware data providers. */
11
    hierarchies?: {
12
      row?: PivotChartHierarchyDefinition;
13
      column?: PivotChartHierarchyDefinition;
14
    };
15
  /**
16
     * Canonical long-form analytical frame. The matrix above is a renderer view
17
     * retained for efficient Cartesian drawing, while every semantic channel
18
     * resolves against stable field IDs in this frame.
19
     */
20
    analyticalFrame?: PivotChartAnalyticalFrame
21
}

`PivotChartSemanticType`

1
export type PivotChartSemanticType =
2
  | 'category'
3
  | 'number'
4
  | 'date'
5
  | 'geographic'
6
  | 'identifier';

`PivotChartFieldDescriptor`

1
interface PivotChartFieldDescriptor {
2
  id: string;
3
  label: string;
4
  role: 'dimension' | 'measure';
5
  semanticType: PivotChartSemanticType;
6
  sourceField?: ColumnProp;
7
  aggregator?: string;
8
  format?: string
9
}

`PivotChartDimensionValue`

1
interface PivotChartDimensionValue {
2
  value: string | number | boolean | null;
3
  label: string;
4
  path?: PivotPath;
5
  labels?: string[]
6
}

`PivotChartObservation`

1
interface PivotChartObservation {
2
  id: string;
3
  dimensions: Record<string, PivotChartDimensionValue>;
4
  measures: Record<string, number | null>;
5
  displayMeasures?: Record<string, string | null>
6
}

`PivotChartDerivedViews`

1
interface PivotChartDerivedViews {
2
  bins?: PivotChartJsonValue[];
3
  quantiles?: PivotChartJsonValue[];
4
  ranges?: PivotChartJsonValue[];
5
  flowEdges?: PivotChartJsonValue[];
6
  financial?: PivotChartJsonValue[];
7
  geographicFeatures?: PivotChartJsonValue[]
8
}

`PivotChartAnalyticalFrame`

1
interface PivotChartAnalyticalFrame {
2
  fields: PivotChartFieldDescriptor[];
3
  observations: PivotChartObservation[];
4
  hierarchies?: PivotChartDataset['hierarchies'];
5
  derived?: PivotChartDerivedViews
6
}

`PivotChartPresentation`

1
interface PivotChartPresentation {
2
  title?: string;
3
  subtitle?: string;
4
  legendPosition?: PivotChartLegendPosition;
5
  dataLabels?: boolean;
6
  xAxisTitle?: string;
7
  yAxisTitle?: string
8
}

`PivotChartDataOptions`

1
interface PivotChartDataOptions {
2
  chartType?: PivotChartType;
3
  seriesIds?: string[];
4
  /** Measure carried by categories when Pivot values are placed on rows. */
5
    categoryMeasure?: PivotChartMeasureSelection;
6
  totals?: PivotChartTotalsMode;
7
  limits?: Partial<PivotChartLimits>;
8
  bindings?: PivotChartBindings
9
}

`PivotChartDataScope`

1
interface PivotChartDataScope {
2
  rowPath: PivotPath;
3
  columnPath?: PivotPath
4
}

`PivotChartDataQueryOptions` (Extended from `index.ts`)

1
interface PivotChartDataQueryOptions {
2
  /** Optional committed semantic scope used for an initial or explicit slice. */
3
    scope?: PivotChartDataScope
4
}

`PivotChartInitialScope`

1
interface PivotChartInitialScope {
2
  /** Parent row member whose immediate children form the initial categories. */
3
    rowPath: PivotPath;
4
  /** Display labels aligned one-to-one with `rowPath` for breadcrumbs. */
5
    rowLabels: string[];
6
  /** Parent column member whose immediate children form the initial series. */
7
    columnPath?: PivotPath;
8
  /** Display labels aligned one-to-one with `columnPath` for breadcrumbs. */
9
    columnLabels?: string[]
10
}

`PivotChartCreateParams` (Extended from `index.ts`)

1
interface PivotChartCreateParams {
2
  container: HTMLElement;
3
  linked?: boolean;
4
  /** Creation-only semantic scope, persisted as the chart's drill state. */
5
    initialScope?: PivotChartInitialScope;
6
  presentation?: PivotChartPresentation;
7
  theme?: PivotChartTheme;
8
  chartOptions?: PivotChartOptions;
9
  /** Controls whether drill navigation is local, Pivot-owned, synchronized, or application-owned. */
10
    drillSyncMode?: PivotChartDrillSyncMode
11
}

`PivotChartUpdatePatch` (Extended from `index.ts`)

1
interface PivotChartUpdatePatch {
2
  linked?: boolean;
3
  presentation?: Partial<PivotChartPresentation>;
4
  theme?: PivotChartTheme;
5
  chartOptions?: PivotChartOptions;
6
  drillSyncMode?: PivotChartDrillSyncMode
7
}

`PivotChartJsonValue`

1
export type PivotChartJsonValue =
2
  | null
3
  | boolean
4
  | number
5
  | string
6
  | PivotChartJsonValue[]
7
  | { [key: string]: PivotChartJsonValue };

`PivotChartBindingChannel`

1
export type PivotChartBindingChannel =
2
  | 'category'
3
  | 'geographic'
4
  | 'series'
5
  | 'value'
6
  | 'x'
7
  | 'y'
8
  | 'size'
9
  | 'color'
10
  | 'shape'
11
  | 'angle'
12
  | 'radius'
13
  | 'hierarchy'
14
  | 'parent'
15
  | 'child'
16
  | 'weight'
17
  | 'source'
18
  | 'target'
19
  | 'start'
20
  | 'end'
21
  | 'low'
22
  | 'high'
23
  | 'open'
24
  | 'close'
25
  | 'volume'
26
  | 'actual'
27
  | 'target'
28
  | 'variance'
29
  | 'facetRow'
30
  | 'facetColumn'
31
  | 'label'
32
  | 'tooltip';

`PivotChartBindings`

Stable analytical field IDs assigned to semantic renderer channels. Empty and omitted channels are equivalent.

1
/**
2
 * Stable analytical field IDs assigned to semantic renderer channels.
3
 * Empty and omitted channels are equivalent.
4
 */
5
export type PivotChartBindings = Partial<
6
  Record<PivotChartBindingChannel, string[]>
7
>;

`PivotChartOptions`

1
export type PivotChartOptions = Record<string, PivotChartJsonValue>;

`PivotChartDrillAxisState`

1
interface PivotChartDrillAxisState {
2
  path: PivotPath;
3
  /** Selected hierarchy level, or `-1` at the hierarchy root. */
4
    levelIndex: number
5
}

`PivotChartDrillScope`

1
interface PivotChartDrillScope {
2
  row: PivotChartDrillAxisState;
3
  column: PivotChartDrillAxisState
4
}

`PivotChartDrillFrame` (Extended from `index.ts`)

1
interface PivotChartDrillFrame {
2
  rowLabels: string[];
3
  columnLabels: string[]
4
}

`PivotChartDrillState`

1
interface PivotChartDrillState {
2
  active: PivotChartDrillScope;
3
  /** Ordered root-to-current breadcrumb frames. */
4
    frames: PivotChartDrillFrame[];
5
  /** Dataset revision that produced the active frame; null until rebound. */
6
    revision: number | null
7
}

`PivotChartModel`

1
interface PivotChartModel {
2
  version: typeof PIVOT_CHART_MODEL_VERSION;
3
  chartId: string;
4
  chartType: PivotChartType;
5
  linked: boolean;
6
  totals: PivotChartTotalsMode;
7
  seriesIds?: string[];
8
  categoryMeasure?: PivotChartMeasureSelection;
9
  presentation: PivotChartPresentation;
10
  theme: PivotChartTheme;
11
  /** Captured only for an unlinked chart. */
12
    dataset?: PivotChartDataset;
13
  bindings: PivotChartBindings;
14
  chartOptions: PivotChartOptions;
15
  drill: PivotChartDrillState;
16
  drillSyncMode: PivotChartDrillSyncMode
17
}

`PivotChartRestoreOptions`

1
interface PivotChartRestoreOptions {
2
  container: HTMLElement;
3
  chartId?: string
4
}

`PivotChartDownloadFormat`

1
export type PivotChartDownloadFormat = 'png' | 'pdf';

`PivotChartDownloadOptions`

1
interface PivotChartDownloadOptions {
2
  fileName?: string;
3
  width?: number;
4
  height?: number;
5
  fileFormat?: PivotChartDownloadFormat
6
}

`PivotChartImageOptions`

1
interface PivotChartImageOptions {
2
  width?: number;
3
  height?: number;
4
  fileFormat?: 'png'
5
}

`PivotChartNodeClick`

1
interface PivotChartNodeClick {
2
  category: PivotChartCategory;
3
  series: PivotChartSeries;
4
  value: number | null;
5
  /** Bound relationship-channel values for scatter/bubble points. */
6
    channelValues?: Partial<Record<'x' | 'y' | 'size', number>>;
7
  /** Series descriptors that own relationship-channel values. */
8
    channelSeries?: Partial<Record<'x' | 'y' | 'size', PivotChartSeries>>;
9
  originalEvent?: Event
10
}

`PivotChartTooltipChannel`

1
export type PivotChartTooltipChannel = 'x' | 'y' | 'size';

`PivotChartTooltipContext`

1
interface PivotChartTooltipContext {
2
  chartId: string;
3
  chartType: PivotChartType;
4
  category: PivotChartCategory;
5
  series: PivotChartSeries;
6
  value: number | null;
7
  displayValue: string;
8
  color: string;
9
  drillable: boolean;
10
  channelValues?: Partial<Record<PivotChartTooltipChannel, number>>;
11
  channelSeries?: Partial<
12
      Record<PivotChartTooltipChannel, PivotChartSeries>
13
    >;
14
  channelDisplayValues?: Partial<
15
      Record<PivotChartTooltipChannel, string>
16
    >
17
}

`PivotChartTooltipRow`

1
interface PivotChartTooltipRow {
2
  label: string;
3
  value: string;
4
  color?: string
5
}

`PivotChartTooltipContent`

1
interface PivotChartTooltipContent {
2
  title?: string;
3
  rows?: readonly PivotChartTooltipRow[];
4
  footer?: string;
5
  ariaLabel?: string
6
}

`PivotChartTooltipResult`

1
export type PivotChartTooltipResult =
2
  | PivotChartTooltipContent
3
  | string
4
  | HTMLElement
5
  | null
6
  | undefined;

`PivotChartTooltipFormatter`

1
export type PivotChartTooltipFormatter = (
2
  context: PivotChartTooltipContext,
3
  defaultContent: PivotChartTooltipContent,
4
) => PivotChartTooltipResult;

`PivotChartRenderInput`

1
interface PivotChartRenderInput {
2
  chartId: string;
3
  container: HTMLElement;
4
  chartType: PivotChartType;
5
  dataset: PivotChartDataset;
6
  bindings: PivotChartBindings;
7
  presentation: PivotChartPresentation;
8
  /** Validated chart-specific overrides; omitted keys use catalog defaults. */
9
    chartOptions?: PivotChartOptions;
10
  theme: PivotChartTheme;
11
  localeText: PivotChartsLocaleText;
12
  /** Preview mode renders decorative, non-interactive compact chart marks. */
13
    renderMode?: 'chart' | 'preview';
14
  onNodeClick: (detail: PivotChartNodeClick) => void
15
}

`PivotChartRendererCapabilities`

1
interface PivotChartRendererCapabilities {
2
  supportedTypes: readonly PivotChartType[];
3
  download?: boolean;
4
  downloadFormats?: readonly PivotChartDownloadFormat[];
5
  imageDataUrl?: boolean
6
}

`PivotChartRenderer`

1
interface PivotChartRenderer {
2
  readonly capabilities: PivotChartRendererCapabilities;
3
  create(
4
      input: PivotChartRenderInput,
5
    ): PivotChartRendererInstance | Promise<PivotChartRendererInstance>
6
}

`PivotChartRendererInstance`

1
interface PivotChartRendererInstance {
2
  update(input: PivotChartRenderInput): void | Promise<void>;
3
  destroy(): void;
4
  focus?(): void;
5
  download?(options?: PivotChartDownloadOptions): Promise<void>;
6
  getImageDataURL?(options?: PivotChartImageOptions): Promise<string>
7
}

`PivotChartDataRequest`

1
interface PivotChartDataRequest {
2
  requestId: string;
3
  viewId: string;
4
  fieldsVersion: string;
5
  loadOptions: PivotLoadOptions;
6
  uiState?: PivotUiStateHints;
7
  axisState: {
8
      rowExpandedPaths?: PivotPath[];
9
      columnExpandedPaths?: PivotPath[];
10
    };
11
  chart: {
12
      seriesIds?: string[];
13
      categoryMeasure?: PivotChartMeasureSelection;
14
      totals: PivotChartTotalsMode;
15
      limits: PivotChartLimits;
16
      bindings: PivotChartBindings;
17
      scope: PivotChartSemanticScope;
18
    }
19
}

`PivotChartSemanticScope`

1
interface PivotChartSemanticScope {
2
  /** Committed Pivot revision the provider must echo in its response. */
3
    revision: number;
4
  /** Active parent row member. The response contains its immediate children. */
5
    rowPath: PivotPath;
6
  /** Active parent column member. Reserved for column-axis drill navigation. */
7
    columnPath: PivotPath;
8
  /** Absolute immediate-child row depth requested for this frame. */
9
    rowDepth: number;
10
  /** Absolute immediate-child column depth requested for this frame. */
11
    columnDepth: number
12
}

`PivotChartDataResponse`

1
interface PivotChartDataResponse {
2
  requestId: string;
3
  scope: PivotChartSemanticScope;
4
  categories: PivotChartCategory[];
5
  series: PivotChartSeries[];
6
  values: Array<Array<number | null>>;
7
  displayValues?: Array<Array<string | null>>;
8
  hierarchies: {
9
      row?: PivotChartHierarchyDefinition;
10
      column?: PivotChartHierarchyDefinition;
11
    };
12
  totalCategoryCount: number;
13
  totalSeriesCount: number
14
}

`PivotChartDataProvider`

1
interface PivotChartDataProvider {
2
  load(
3
      request: PivotChartDataRequest,
4
      context: { signal: AbortSignal },
5
    ): Promise<PivotChartDataResponse>
6
}

`PivotChartsConfig`

1
interface PivotChartsConfig {
2
  renderer?: PivotChartRenderer;
3
  dataProvider?: PivotChartDataProvider;
4
  defaultChartType?: PivotChartType;
5
  defaultTotals?: PivotChartTotalsMode;
6
  limits?: Partial<PivotChartLimits>;
7
  localeText?: PivotChartsLocaleTextOptions;
8
  defaultDrillSyncMode?: PivotChartDrillSyncMode;
9
  /**
10
     * Optional application adapter for Pivot synchronization. When omitted,
11
     * the active Pivot plugin applies the semantic frontier directly.
12
     */
13
    synchronizeDrill?: (
14
      detail: PivotChartDrillSyncEventDetail,
15
      context: { signal: AbortSignal },
16
    ) => void | Promise<void>
17
}

`PivotChartsUiConfig`

1
interface PivotChartsUiConfig {
2
  contextMenu?: boolean;
3
  dialogParent?: HTMLElement
4
}

`PivotChartRef`

1
interface PivotChartRef {
2
  readonly id: string;
3
  readonly container: HTMLElement;
4
  readonly model: PivotChartModel;
5
  update(patch: PivotChartUpdatePatch): Promise<void>;
6
  canDrillDown(target: PivotChartDrillTarget | PivotChartCategory): boolean;
7
  drillDown(target: PivotChartDrillTarget | PivotChartCategory): Promise<void>;
8
  drillUp(): Promise<void>;
9
  drillTo(frameIndex: number): Promise<void>;
10
  resetDrill(): Promise<void>;
11
  retryDrill(): Promise<void>;
12
  getDrillState(): PivotChartDrillState;
13
  focus(): void;
14
  destroy(): void
15
}

`PivotChartDrillTarget`

1
export type PivotChartDrillTarget =
2
  | { axis: 'row'; category: PivotChartCategory }
3
  | { axis: 'column'; series: PivotChartSeries }
4
  | {
5
      axis: 'both';
6
      category: PivotChartCategory;
7
      series: PivotChartSeries;
8
    };

`PivotChartDrillAction`

1
export type PivotChartDrillAction = 'down' | 'up' | 'to' | 'reset' | 'retry';

`PivotChartDrillEventDetail`

1
interface PivotChartDrillEventDetail {
2
  chartId: string;
3
  action: PivotChartDrillAction;
4
  from: PivotChartDrillState;
5
  to: PivotChartDrillState
6
}

`PivotChartDrilledEventDetail` (Extended from `index.ts`)

1
interface PivotChartDrilledEventDetail {
2
  model: PivotChartModel;
3
  dataset: PivotChartDataset
4
}

`PivotChartDrillErrorEventDetail` (Extended from `index.ts`)

1
interface PivotChartDrillErrorEventDetail {
2
  error: Error
3
}

`PivotChartDrillSyncEventDetail` (Extended from `index.ts`)

1
interface PivotChartDrillSyncEventDetail {
2
  mode: Exclude<PivotChartDrillSyncMode, 'chart'>
3
}

`PivotChartCreatedEventDetail`

1
interface PivotChartCreatedEventDetail {
2
  chartId: string;
3
  ref: PivotChartRef
4
}

`PivotChartUpdatedEventDetail`

1
interface PivotChartUpdatedEventDetail {
2
  chartId: string;
3
  reason: PivotChartUpdateReason;
4
  model: PivotChartModel
5
}

`PivotChartDestroyedEventDetail`

1
interface PivotChartDestroyedEventDetail {
2
  chartId: string
3
}

`PivotChartNodeClickEventDetail` (Extended from `index.ts`)

1
interface PivotChartNodeClickEventDetail {
2
  chartId: string;
3
  categoryPath: PivotPath;
4
  columnPath: PivotPath;
5
  measure?: ColumnProp;
6
  aggregator?: string
7
}

`PivotChartErrorEventDetail`

1
interface PivotChartErrorEventDetail {
2
  chartId?: string;
3
  error: Error
4
}

`PivotChartProjectorContext`

1
interface PivotChartProjectorContext {
2
  /** Visible logical body rows after grouping, filtering, and sorting. */
3
    visibleRows: DataType[];
4
  /** Grid column types used to preserve measure display formatting. */
5
    columnTypes?: ColumnTypes;
6
  localeText?: PivotChartsLocaleText
7
}

`isPivotChartType`

1
export function isPivotChartType(value: unknown): value is PivotChartType;

`resolvePivotChartLimits`

1
export function resolvePivotChartLimits(
2
  limits?: Partial<PivotChartLimits>,
3
): PivotChartLimits;

`assertPivotChartLimits`

1
export function assertPivotChartLimits(
2
  dataset: Pick<PivotChartDataset, 'categories' | 'series'>,
3
  limits: PivotChartLimits,
4
);

`selectPivotChartSeries`

1
export function selectPivotChartSeries(
2
  series: PivotChartSeries[],
3
  seriesIds?: readonly string[],
4
);

`assertPivotChartTypeShape`

1
export function assertPivotChartTypeShape(
2
  chartType: PivotChartType,
3
  dataset: PivotChartDataset,
4
  localeText?: PivotChartsLocaleText,
5
  bindings: PivotChartBindings =;

`assertRelationshipChartBindings`

1
export function assertRelationshipChartBindings(
2
  chartType: PivotChartType,
3
  dataset: PivotChartDataset,
4
  bindings: PivotChartBindings,
5
  localeText?: PivotChartsLocaleText,
6
);

`validatePivotChartDataResponse`

1
export function validatePivotChartDataResponse(
2
  response: PivotChartDataResponse,
3
  request: PivotChartDataRequest,
4
  limits: PivotChartLimits,
5
): PivotChartDataset;

`assertPivotChartDataset`

1
export function assertPivotChartDataset(dataset: PivotChartDataset);

`validatePivotChartModel`

1
export function validatePivotChartModel(model: unknown): PivotChartModel;

`createPivotChartGeographicCapabilityPack`

Creates an opt-in geographic capability. Merely importing Pivot Charts does not install geographic types or load projection/map data.

1
export function createPivotChartGeographicCapabilityPack(
2
  provider: PivotChartGeographicProvider,
3
): PivotChartGeographicCapabilityPack;

`getAvailablePivotChartGeographicTypes`

1
export function getAvailablePivotChartGeographicTypes(
2
  pack?: PivotChartGeographicCapabilityPack,
3
): readonly PivotChartGeographicType[];

`getPivotChartGeographicDefinitions`

Catalog-extension hook used by gallery hosts. The base catalog remains unchanged; a host receives no geographic entries until a pack is installed.

1
export function getPivotChartGeographicDefinitions(
2
  pack?: PivotChartGeographicCapabilityPack,
3
): readonly PivotChartGeographicDefinition[];

`isPivotChartGeographicType`

1
export function isPivotChartGeographicType(
2
  value: unknown,
3
): value is PivotChartGeographicType;

`assertGeographicRequest`

1
export function assertGeographicRequest(
2
  request: PivotChartGeographicRequest,
3
): void;

`assertGeographicData`

1
export function assertGeographicData(
2
  data: PivotChartGeographicData,
3
  request: Pick<PivotChartGeographicRequest, 'chartType' | 'dataset'>,
4
): void;

`PIVOT_CHART_GEOGRAPHIC_DEFINITIONS`

1
PIVOT_CHART_GEOGRAPHIC_DEFINITIONS: readonly PivotChartGeographicDefinition[];

`PivotChartGeographicDataError`

1
class PivotChartGeographicDataError {}

`PivotChartGeographicType`

Geographic charts are intentionally not part of the base chart catalog. Import and install a geographic capability pack to make these types available.

1
/**
2
 * Geographic charts are intentionally not part of the base chart catalog.
3
 * Import and install a geographic capability pack to make these types
4
 * available.
5
 */
6
export type PivotChartGeographicType =
7
  | 'choropleth'
8
  | 'proportionalSymbolMap'
9
  | 'geographicHeatmap';

`PivotChartGeographicPosition`

1
export type PivotChartGeographicPosition = readonly [
2
  longitude: number,
3
  latitude: number,
4
];

`PivotChartGeographicViewport`

1
interface PivotChartGeographicViewport {
2
  width: number;
3
  height: number;
4
  pixelRatio?: number
5
}

`PivotChartGeographicRequest`

1
interface PivotChartGeographicRequest {
2
  chartId: string;
3
  chartType: PivotChartGeographicType;
4
  dataset: PivotChartDataset;
5
  bindings: PivotChartBindings;
6
  theme: PivotChartTheme;
7
  viewport: PivotChartGeographicViewport
8
}

`PivotChartGeographicRegion`

1
interface PivotChartGeographicRegion {
2
  id: string;
3
  label: string;
4
  /**
5
     * Provider-projected SVG path. Projection and map assets remain owned by the
6
     * provider, keeping them out of the Enterprise bundle.
7
     */
8
    path: string;
9
  categoryId: string;
10
  seriesId: string;
11
  value: number | null;
12
  properties?: Record<string, PivotChartJsonValue>
13
}

`PivotChartGeographicSymbol`

1
interface PivotChartGeographicSymbol {
2
  id: string;
3
  label: string;
4
  position: PivotChartGeographicPosition;
5
  /** Provider-projected viewport coordinate used by the optional renderer. */
6
    projectedPosition: readonly [x: number, y: number];
7
  categoryId: string;
8
  seriesId: string;
9
  value: number | null;
10
  size: number | null;
11
  properties?: Record<string, PivotChartJsonValue>
12
}

`PivotChartGeographicHeatPoint`

1
interface PivotChartGeographicHeatPoint {
2
  id: string;
3
  position: PivotChartGeographicPosition;
4
  /** Provider-projected viewport coordinate used by the optional renderer. */
5
    projectedPosition: readonly [x: number, y: number];
6
  categoryId?: string;
7
  seriesId?: string;
8
  value: number;
9
  radius?: number;
10
  properties?: Record<string, PivotChartJsonValue>
11
}

`PivotChartChoroplethData` (Extended from `index.ts`)

1
interface PivotChartChoroplethData {
2
  chartType: 'choropleth';
3
  regions: PivotChartGeographicRegion[]
4
}

`PivotChartProportionalSymbolData` (Extended from `index.ts`)

1
interface PivotChartProportionalSymbolData {
2
  chartType: 'proportionalSymbolMap';
3
  symbols: PivotChartGeographicSymbol[]
4
}

`PivotChartGeographicHeatmapData` (Extended from `index.ts`)

1
interface PivotChartGeographicHeatmapData {
2
  chartType: 'geographicHeatmap';
3
  points: PivotChartGeographicHeatPoint[]
4
}

`PivotChartGeographicData`

1
export type PivotChartGeographicData =
2
  | PivotChartChoroplethData
3
  | PivotChartProportionalSymbolData
4
  | PivotChartGeographicHeatmapData;

`PivotChartGeographicProvider`

1
interface PivotChartGeographicProvider {
2
  readonly id: string;
3
  readonly supportedTypes: readonly PivotChartGeographicType[];
4
  /**
5
     * Loads map data and applies the provider-owned projection. The operation
6
     * must observe the supplied signal and avoid mutating the request.
7
     */
8
    load(
9
      request: Readonly<PivotChartGeographicRequest>,
10
      context: { signal: AbortSignal },
11
    ): Promise<PivotChartGeographicData>
12
}

`PivotChartGeographicDefinition`

1
interface PivotChartGeographicDefinition {
2
  type: PivotChartGeographicType;
3
  family: 'geographic';
4
  localization: {
5
      labelKey: PivotChartGeographicType;
6
      descriptionKey: PivotChartGeographicType;
7
    };
8
  channels: readonly {
9
      channel: 'geographic' | 'value' | 'size';
10
      min: number;
11
      max?: number;
12
    }[];
13
  documentationSlug: string
14
}

`PivotChartGeographicCapabilityPack`

1
interface PivotChartGeographicCapabilityPack {
2
  readonly id: string;
3
  readonly provider: PivotChartGeographicProvider;
4
  readonly definitions: readonly PivotChartGeographicDefinition[];
5
  readonly supportedTypes: readonly PivotChartGeographicType[];
6
  load(
7
      request: PivotChartGeographicRequest,
8
      context: { signal: AbortSignal },
9
    ): Promise<PivotChartGeographicData>;
10
  /**
11
     * Starts an asset-free SVG render lifecycle backed by this pack's provider.
12
     * Provider loads are cancelled when superseded or destroyed.
13
     */
14
    render(
15
      input: PivotChartGeographicRenderInput,
16
    ): PivotChartGeographicRendererInstance
17
}

`PivotChartGeographicLocaleText`

1
interface PivotChartGeographicLocaleText {
2
  chartAriaLabel(type: PivotChartGeographicType): string;
3
  loading: string;
4
  loadError(error: Error): string;
5
  regionAriaLabel(label: string, value: string): string;
6
  symbolAriaLabel(label: string, value: string, size: string): string;
7
  heatPointAriaLabel(value: string): string;
8
  formatValue(value: number | null): string
9
}

`PivotChartGeographicDatum`

1
export type PivotChartGeographicDatum =
2
  | PivotChartGeographicRegion
3
  | PivotChartGeographicSymbol
4
  | PivotChartGeographicHeatPoint;

`PivotChartGeographicRenderInput`

1
interface PivotChartGeographicRenderInput {
2
  container: HTMLElement;
3
  request: PivotChartGeographicRequest;
4
  localeText: PivotChartGeographicLocaleText;
5
  onNodeClick?: (
6
      detail: {
7
        chartType: PivotChartGeographicType;
8
        datum: PivotChartGeographicDatum;
9
        originalEvent: Event;
10
      },
11
    ) => void;
12
  onError?: (error: Error) => void
13
}

`PivotChartGeographicRendererInstance`

1
interface PivotChartGeographicRendererInstance {
2
  readonly ready: Promise<void>;
3
  update(input: PivotChartGeographicRenderInput): Promise<void>;
4
  focus(): void;
5
  destroy(): void
6
}

`PivotChartsPlugin`

Dependencies

Required PivotPlugin: Consumes committed Pivot runtime snapshots and semantic result metadata.
Event integration PIVOT_MODEL_CHANGED_EVENT, afterfilterapply, aftersortingapply, groupexpandclick, aftersourceset, afterthemechanged: Keeps linked charts synchronized with the logical Pivot view.
Config integration grid.pivotCharts: Reads the renderer, complete-data provider, defaults, and safety limits.

1
class PivotChartsPlugin {
2
  async getChartData(
3
    options: PivotChartDataQueryOptions =;
4

5
  async createChart(params: PivotChartCreateParams): Promise<PivotChartRef>;
6

7
  async updateChart(
8
    chartId: string,
9
    patch: PivotChartUpdatePatch,
10
  ): Promise<void>;
11

12
  /**
13
     * Retries the current chart data/render operation without changing options.
14
     * UI integrations use this after a transient provider or renderer failure.
15
     */
16
  async refreshChart(chartId: string): Promise<void>;
17

18
  canDrillDown(
19
    chartId: string,
20
    input: PivotChartDrillTarget | PivotChartCategory,
21
  ): boolean;
22

23
  async drillDownChart(
24
    chartId: string,
25
    input: PivotChartDrillTarget | PivotChartCategory,
26
  ): Promise<void>;
27

28
  async drillUpChart(chartId: string): Promise<void>;
29

30
  async drillToChart(chartId: string, frameIndex: number): Promise<void>;
31

32
  async resetChartDrill(chartId: string): Promise<void>;
33

34
  async retryChartDrill(chartId: string): Promise<void>;
35

36
  destroyChart(chartId: string);
37

38
  destroyAllCharts();
39

40
  getChartModels(): PivotChartModel[];
41

42
  async restoreChart(
43
    model: PivotChartModel,
44
    options: PivotChartRestoreOptions,
45
  ): Promise<PivotChartRef>;
46

47
  async downloadChart(
48
    chartId: string,
49
    options?: PivotChartDownloadOptions,
50
  );
51

52
  async getChartImageDataURL(
53
    chartId: string,
54
    options?: PivotChartImageOptions,
55
  );
56
}

`createPivotChartsLocaleText`

1
export function createPivotChartsLocaleText(
2
  localeText?: PivotChartsLocaleTextOptions,
3
): PivotChartsLocaleText;

`PivotChartDatumLocaleContext`

1
interface PivotChartDatumLocaleContext {
2
  category: PivotChartCategory;
3
  series: PivotChartSeries;
4
  value: number | null;
5
  displayValue: string
6
}

`PivotChartRelationshipDatumLocaleContext`

1
interface PivotChartRelationshipDatumLocaleContext {
2
  category: PivotChartCategory;
3
  x: { series: PivotChartSeries; value: number; displayValue: string };
4
  y: { series: PivotChartSeries; value: number; displayValue: string };
5
  size?: { series: PivotChartSeries; value: number; displayValue: string }
6
}

`PivotChartsLocaleText`

1
interface PivotChartsLocaleText {
2
  dialog: {
3
      kicker: string;
4
      untitledChart: string;
5
      chartAriaLabel: (title: string | undefined) => string;
6
      settingsAriaLabel: string;
7
    };
8
  actions: {
9
      exportChart: string;
10
      downloadPng: string;
11
      downloadPdf: string;
12
      close: string;
13
      closeButtonText: string;
14
      retry: string;
15
      viewData: string;
16
      viewChart: string;
17
    };
18
  status: {
19
      loading: string;
20
      empty: string;
21
      formatError: (error: Error) => string;
22
    };
23
  drill: {
24
      toolbarAriaLabel: string;
25
      breadcrumbAriaLabel: string;
26
      root: string;
27
      currentLevel: (label: string) => string;
28
      loading: (label: string) => string;
29
      loaded: (label: string) => string;
30
      retry: string;
31
      formatError: (error: Error) => string;
32
      drillableDatum: (context: PivotChartDatumLocaleContext) => string;
33
      relationshipDrillableDatum:
34
        (context: PivotChartRelationshipDatumLocaleContext) => string;
35
    };
36
  controls: {
37
      chartType: string;
38
      valueSeries: string;
39
      xMeasure: string;
40
      yMeasure: string;
41
      sizeMeasure: string;
42
      title: string;
43
      subtitle: string;
44
      legend: string;
45
      dataLabels: string;
46
      xAxisTitle: string;
47
      yAxisTitle: string;
48
      totals: string;
49
      drillSyncMode: string;
50
      theme: string;
51
      keepLinked: string;
52
    };
53
  chartOptions: {
54
      heading: string;
55
      description: string;
56
      resetAll: string;
57
      resetOption: (label: string) => string;
58
      valueLabel: (label: string, value: number) => string;
59
      labels: Record<PivotChartOptionKey, string>;
60
      descriptions: Record<PivotChartOptionKey, string>;
61
    };
62
  gallery: {
63
      tabs: {
64
        chart: string;
65
        data: string;
66
        customize: string;
67
      };
68
      searchPlaceholder: string;
69
      searchAriaLabel: string;
70
      recommended: string;
71
      families: Record<PivotChartFamily, string>;
72
      noResults: string;
73
      compatibilityReason: (reason: PivotChartCompatibilityReason) => string;
74
    };
75
  chartTypes: Record<PivotChartType, string>;
76
  chartDescriptions: Record<PivotChartType, string>;
77
  legendPositions: {
78
      automatic: string;
79
      top: string;
80
      right: string;
81
      bottom: string;
82
      left: string;
83
      none: string;
84
    };
85
  totals: Record<PivotChartTotalsMode, string>;
86
  drillSyncModes: Record<PivotChartDrillSyncMode, string>;
87
  themes: {
88
      auto: string;
89
      default: string;
90
      material: string;
91
      compact: string;
92
      darkMaterial: string;
93
      darkCompact: string;
94
      custom: (theme: string) => string;
95
    };
96
  contextMenu: {
97
      createChart: string;
98
      pluginRequired: string;
99
      rendererRequired: string;
100
      serverProviderRequired: string;
101
    };
102
  uiErrors: {
103
      destroyed: string;
104
      containerMissing: string;
105
      creationClosed: string;
106
      pluginRequired: string;
107
    };
108
  data: {
109
      total: string;
110
      hierarchySeparator: string;
111
    };
112
  dataTable: {
113
      regionAriaLabel: string;
114
      tableCaption: string;
115
      categoryHeader: string;
116
      emptyValue: string;
117
      sortAscending: (columnLabel: string) => string;
118
      sortDescending: (columnLabel: string) => string;
119
      sortedAscending: (columnLabel: string) => string;
120
      sortedDescending: (columnLabel: string) => string;
121
    };
122
  renderer: {
123
      chartAriaLabel: (title: string | undefined) => string;
124
      legendAriaLabel: string;
125
      legendItemAriaLabel: (series: PivotChartSeries) => string;
126
      legendCategoryItemAriaLabel: (category: PivotChartCategory) => string;
127
      legendOverflow: (hiddenCount: number) => string;
128
      datumAriaLabel: (context: PivotChartDatumLocaleContext) => string;
129
      datumTitle: (context: PivotChartDatumLocaleContext) => string;
130
      relationshipDatumAriaLabel:
131
        (context: PivotChartRelationshipDatumLocaleContext) => string;
132
      relationshipDatumTitle:
133
        (context: PivotChartRelationshipDatumLocaleContext) => string;
134
      tooltipDrillHint: string;
135
      missingValue: string;
136
      formatNumber: (value: number) => string;
137
      formatPercent: (value: number) => string;
138
      downloadFileName: string;
139
      pngUnavailable: string;
140
      pdfUnavailable: string;
141
      pdfEncodeError: string;
142
      rasterizeError: string;
143
      canvasRequired: string;
144
      destroyedRenderer: string;
145
      unsupportedChartType: (chartType: string) => string;
146
      valueSeriesRequired: (chartType: string) => string;
147
      singleSeriesRequired: (chartType: string) => string;
148
      rowHierarchyRequired: string;
149
      dateCategoriesRequired: string;
150
      distributionViewRequired: string;
151
      nonNegativeValuesRequired: string;
152
      relationshipBindingsRequired: (chartType: string) => string;
153
      relationshipDataRequired: (chartType: string) => string;
154
      nonNegativeSizeRequired: string;
155
      minimumSeriesRequired: (chartType: string, minimum: number) => string;
156
      maximumSeriesRequired: (chartType: string, maximum: number) => string;
157
    }
158
}

`PivotChartsLocaleTextOptions`

1
interface PivotChartsLocaleTextOptions {
2
  dialog?: Partial<PivotChartsLocaleText['dialog']>;
3
  actions?: Partial<PivotChartsLocaleText['actions']>;
4
  status?: Partial<PivotChartsLocaleText['status']>;
5
  drill?: Partial<PivotChartsLocaleText['drill']>;
6
  controls?: Partial<PivotChartsLocaleText['controls']>;
7
  chartOptions?: {
8
      heading?: string;
9
      description?: string;
10
      resetAll?: string;
11
      resetOption?: PivotChartsLocaleText['chartOptions']['resetOption'];
12
      valueLabel?: PivotChartsLocaleText['chartOptions']['valueLabel'];
13
      labels?: Partial<PivotChartsLocaleText['chartOptions']['labels']>;
14
      descriptions?: Partial<
15
        PivotChartsLocaleText['chartOptions']['descriptions']
16
      >;
17
    };
18
  gallery?: {
19
      tabs?: Partial<PivotChartsLocaleText['gallery']['tabs']>;
20
      searchPlaceholder?: string;
21
      searchAriaLabel?: string;
22
      recommended?: string;
23
      families?: Partial<PivotChartsLocaleText['gallery']['families']>;
24
      noResults?: string;
25
      compatibilityReason?: PivotChartsLocaleText['gallery']['compatibilityReason'];
26
    };
27
  chartTypes?: Partial<PivotChartsLocaleText['chartTypes']>;
28
  chartDescriptions?: Partial<PivotChartsLocaleText['chartDescriptions']>;
29
  legendPositions?: Partial<PivotChartsLocaleText['legendPositions']>;
30
  totals?: Partial<PivotChartsLocaleText['totals']>;
31
  drillSyncModes?: Partial<PivotChartsLocaleText['drillSyncModes']>;
32
  themes?: Partial<PivotChartsLocaleText['themes']>;
33
  contextMenu?: Partial<PivotChartsLocaleText['contextMenu']>;
34
  uiErrors?: Partial<PivotChartsLocaleText['uiErrors']>;
35
  data?: Partial<PivotChartsLocaleText['data']>;
36
  dataTable?: Partial<PivotChartsLocaleText['dataTable']>;
37
  renderer?: Partial<PivotChartsLocaleText['renderer']>
38
}

`DEFAULT_PIVOT_CHARTS_LOCALE_TEXT`

1
DEFAULT_PIVOT_CHARTS_LOCALE_TEXT: {
2
  dialog: { kicker: string; untitledChart: string; chartAriaLabel: (title: string | undefined) => string; settingsAriaLabel: string; };
3
  actions: { exportChart: string; downloadPng: string; downloadPdf: string; close: string; closeButtonText: string; retry: string; viewData: string; viewChart: string; };
4
  status: { loading: string; empty: string; formatError: (error: Error) => string; };
5
  drill: { toolbarAriaLabel: string; breadcrumbAriaLabel: string; root: string; currentLevel: (label: string) => string; loading: (label: string) => string; loaded: (label: string) => string; retry: string; formatError: (error: Error) => string; drillableDatum: ({ category, series, displayValue }: PivotChartDatumLocaleContext) => string; relationshipDrillableDatum: ({ category, x, y, size }: PivotChartRelationshipDatumLocaleContext) => string; };
6
  controls: { chartType: string; valueSeries: string; xMeasure: string; yMeasure: string; sizeMeasure: string; title: string; subtitle: string; legend: string; dataLabels: string; xAxisTitle: string; yAxisTitle: string; totals: string; drillSyncMode: string; theme: string; keepLinked: string; };
7
  chartOptions: { heading: string; description: string; resetAll: string; resetOption: (label: string) => string; valueLabel: (label: string, value: number) => string; labels: { showGridLines: string; markOpacity: string; strokeWidth: string; fillOpacity: string; }; descriptions: { showGridLines: string; markOpacity: string; strokeWidth: string; fillOpacity: string; }; };
8
  gallery: { tabs: { chart: string; data: string; customize: string; }; searchPlaceholder: string; searchAriaLabel: string; recommended: string; families: { column: string; bar: string; line: string; area: string; partToWhole: string; relationship: string; hierarchical: string; combination: string; statistical: string; specialized: string; kpi: string; polar: string; distribution: string; matrix: string; process: string; flow: string; financial: string; }; noResults: string; compatibilityReason: (reason: PivotChartCompatibilityReason) => string; };
9
  chartTypes: { groupedColumn: string; stackedColumn: string; normalizedColumn: string; groupedBar: string; stackedBar: string; normalizedBar: string; line: string; smoothLine: string; steppedLine: string; area: string; steppedArea: string; stackedArea: string; normalizedArea: string; pie: string; donut: string; treemap: string; sunburst: string; scatter: string; bubble: string; columnLine: string; areaLine: string; rangeColumn: string; rangeBar: string; rangeArea: string; confidenceBand: string; errorInterval: string; waterfall: string; lollipop: string; bullet: string; semiDonut: string; rose: string; radarLine: string; radarArea: string; polarColumn: string; stackedPolarColumn: string; normalizedPolarColumn: string; radialBar: string; multiRingRadialBar: string; histogram: string; stripDot: string; heatmap: string; calendarHeatmap: string; densityScatter: string; icicle: string; circlePacking: string; funnel: string; pyramid: string; boxPlot: string; violin: string; rangeInterval: string; sankey: string; chord: string; candlestick: string; ohlc: string; volumePrice: string; gauge: string; kpi: string; progressGauge: string; connectedScatter: string; waffle: string; smallMultiples: string; annotatedTimeSeries: string; timelineRange: string; };
10
  chartDescriptions: { groupedColumn: string; stackedColumn: string; normalizedColumn: string; groupedBar: string; stackedBar: string; normalizedBar: string; line: string; smoothLine: string; steppedLine: string; area: string; steppedArea: string; stackedArea: string; normalizedArea: string; pie: string; donut: string; treemap: string; sunburst: string; scatter: string; bubble: string; columnLine: string; areaLine: string; rangeColumn: string; rangeBar: string; rangeArea: string; confidenceBand: string; errorInterval: string; waterfall: string; lollipop: string; bullet: string; semiDonut: string; rose: string; radarLine: string; radarArea: string; polarColumn: string; stackedPolarColumn: string; normalizedPolarColumn: string; radialBar: string; multiRingRadialBar: string; histogram: string; stripDot: string; heatmap: string; calendarHeatmap: string; densityScatter: string; icicle: string; circlePacking: string; funnel: string; pyramid: string; boxPlot: string; violin: string; rangeInterval: string; sankey: string; chord: string; candlestick: string; ohlc: string; volumePrice: string; gauge: string; kpi: string; progressGauge: string; connectedScatter: string; waffle: string; smallMultiples: string; annotatedTimeSeries: string; timelineRange: string; };
11
  legendPositions: { automatic: string; top: string; right: string; bottom: string; left: string; none: string; };
12
  totals: { none: string; grand: string; subtotals: string; all: string; };
13
  drillSyncModes: { chart: string; pivot: string; both: string; event: string; };
14
  themes: { auto: string; default: string; material: string; compact: string; darkMaterial: string; darkCompact: string; custom: (theme: string) => string; };
15
  contextMenu: { createChart: string; pluginRequired: string; rendererRequired: string; serverProviderRequired: string; };
16
  uiErrors: { destroyed: string; containerMissing: string; creationClosed: string; pluginRequired: string; };
17
  data: { total: string; hierarchySeparator: string; };
18
  dataTable: { regionAriaLabel: string; tableCaption: string; categoryHeader: string; emptyValue: string; sortAscending: (columnLabel: string) => string; sortDescending: (columnLabel: string) => string; sortedAscending: (columnLabel: string) => string; sortedDescending: (columnLabel: string) => string; };
19
  renderer: { chartAriaLabel: (title: string | undefined) => string; legendAriaLabel: string; legendItemAriaLabel: (series: PivotChartSeries) => string; legendCategoryItemAriaLabel: (category: PivotChartCategory) => string; legendOverflow: (hiddenCount: number) => string; datumAriaLabel: ({ category, series, displayValue }: PivotChartDatumLocaleContext) => string; datumTitle: ({ category, series, displayValue }: PivotChartDatumLocaleContext) => string; relationshipDatumAriaLabel: ({ category, x, y, size }: PivotChartRelationshipDatumLocaleContext) => string; relationshipDatumTitle: ({ category, x, y, size }: PivotChartRelationshipDatumLocaleContext) => string; tooltipDrillHint: string; missingValue: string; formatNumber: (value: number) => string; formatPercent: (value: number) => string; downloadFileName: string; pngUnavailable: string; pdfUnavailable: string; pdfEncodeError: string; rasterizeError: string; canvasRequired: string; destroyedRenderer: string; unsupportedChartType: (chartType: string) => string; valueSeriesRequired: (chartType: string) => string; singleSeriesRequired: (chartType: string) => string; rowHierarchyRequired: string; dateCategoriesRequired: string; distributionViewRequired: string; nonNegativeValuesRequired: string; relationshipBindingsRequired: (chartType: string) => string; relationshipDataRequired: (chartType: string) => string; nonNegativeSizeRequired: string; minimumSeriesRequired: (chartType: string, minimum: number) => string; maximumSeriesRequired: (chartType: string, maximum: number) => string; };
20
};

`createPivotChartsRenderer`

Creates the built-in RevoGrid Pivot Charts SVG renderer.

1
export function createPivotChartsRenderer(
2
  options: PivotChartsRendererOptions =;

`PivotChartsRendererOptions`

1
interface PivotChartsRendererOptions {
2
  palette?: readonly string[];
3
  categorySeparator?: string;
4
  fontFamily?: string;
5
  imageEncoder?: (
6
      svg: SVGSVGElement,
7
      options: Required<Pick<PivotChartImageOptions, 'width' | 'height'>>,
8
    ) => Promise<string>;
9
  pdfEncoder?: (
10
      svg: SVGSVGElement,
11
      options: Required<Pick<PivotChartDownloadOptions, 'width' | 'height'>>,
12
    ) => Promise<string>;
13
  /** Disable tooltips or customize the built-in semantic tooltip renderer. */
14
    tooltip?: false | PivotChartTooltipOptions
15
}

`PivotChartUiOpenParams`

1
export type PivotChartUiOpenParams = Omit<PivotChartCreateParams, 'container'>;

`PivotChartsUiPlugin`

Dependencies

Required PivotChartsPlugin: Uses the headless Pivot Charts lifecycle and data APIs.
Optional ContextMenuPlugin: Contributes the optional Pivot Chart row-menu action.
Config integration grid.pivotChartsUi: Reads UI mounting and context-menu behavior from grid.pivotChartsUi.

1
class PivotChartsUiPlugin {
2
  /**
3
     * Opens a UI-owned modeless Pivot chart. The returned chart ref remains
4
     * managed by the headless plugin; closing the dialog destroys that ref.
5
     * If this grid already has an open chart dialog, it is focused and its
6
     * existing chart ref is returned.
7
     */
8
  async openChart(
9
    params: PivotChartUiOpenParams =;
10
}

`PivotChartDialog`

1
export function PivotChartDialog(;

`PivotChartDialogProps`

1
interface PivotChartDialogProps {
2
  readonly model: PivotChartModel;
3
  readonly series: readonly PivotChartSeries[];
4
  readonly dataset?: PivotChartDataset;
5
  readonly renderer?: PivotChartRenderer;
6
  readonly supportedTypes: readonly PivotChartType[];
7
  readonly loading: boolean;
8
  readonly empty: boolean;
9
  readonly error?: Error;
10
  readonly drillLoading?: boolean;
11
  readonly drillError?: Error;
12
  readonly drillPendingLabel?: string;
13
  readonly drillCompletedLabel?: string;
14
  readonly downloadFormats: readonly PivotChartDownloadFormat[];
15
  readonly localeText: PivotChartsLocaleText;
16
  readonly onUpdate: (patch: PivotChartUpdatePatch) => void;
17
  readonly onRetry: () => void;
18
  readonly onDrillBack?: () => void;
19
  readonly onDrillHome?: () => void;
20
  readonly onDrillNavigate?: (frameIndex: number) => void;
21
  readonly onDrillRetry?: () => void;
22
  readonly onDownload: (format: PivotChartDownloadFormat) => void;
23
  readonly onClose: () => void
24
}

`chartRenderers`

1
chartRenderers: Record<"line" | "area" | "kpi" | "groupedColumn" | "stackedColumn" | "normalizedColumn" | "groupedBar" | "stackedBar" | "normalizedBar" | "smoothLine" | "steppedLine" | "steppedArea" | "stackedArea" | "normalizedArea" | "pie" | "donut" | "treemap" | "sunburst" | "scatter" | "bubble" | "densityScatter" | "connectedScatter" | "columnLine" | "areaLine" | "rangeColumn" | "rangeBar" | "rangeArea" | "confidenceBand" | "errorInterval" | "waterfall" | "lollipop" | "bullet" | "semiDonut" | "rose" | "radarLine" | "radarArea" | "polarColumn" | "stackedPolarColumn" | "normalizedPolarColumn" | "radialBar" | "multiRingRadialBar" | "histogram" | "stripDot" | "heatmap" | "calendarHeatmap" | "icicle" | "circlePacking" | "funnel" | "pyramid" | "boxPlot" | "violin" | "rangeInterval" | "sankey" | "chord" | "candlestick" | "ohlc" | "volumePrice" | "gauge" | "progressGauge" | "waffle" | "smallMultiples" | "annotatedTimeSeries" | "timelineRange", PivotChartRenderFunction>;

`renderWaffle`

1
renderWaffle: PivotChartRenderFunction;

`renderHistogram`

1
renderHistogram: PivotChartRenderFunction;

`renderDotPlot`

1
renderDotPlot: PivotChartRenderFunction;

`renderStripDot`

1
renderStripDot: PivotChartRenderFunction;

`renderStripPlot`

1
renderStripPlot: PivotChartRenderFunction;

`renderSmallMultiples`

1
renderSmallMultiples: PivotChartRenderFunction;

`renderCandlestick`

1
renderCandlestick: PivotChartRenderFunction;

`renderOhlc`

1
renderOhlc: PivotChartRenderFunction;

`renderVolumePrice`

1
renderVolumePrice: PivotChartRenderFunction;

`renderChord`

1
renderChord: PivotChartRenderFunction;

`createFlowGraph`

The current Pivot dataset is a category-by-series matrix rather than an explicit edge list. Until a provider supplies the normalized flow view, this deterministic projection treats those two matrix axes as adjacent graph partitions: each positive finite cell becomes one directed edge from its category to its series. Aggregate categories and unconnected nodes are omitted, while original matrix indexes are retained for exact interaction.

1
export function createFlowGraph(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
): PivotChartFlowGraph;

`PivotChartFlowEdge`

1
interface PivotChartFlowEdge {
2
  readonly id: string;
3
  readonly sourceId: string;
4
  readonly targetId: string;
5
  readonly value: number;
6
  readonly category: PivotChartCategory;
7
  readonly categoryIndex: number;
8
  readonly series: PivotChartSeries;
9
  readonly seriesIndex: number
10
}

`PivotChartFlowGraph`

1
interface PivotChartFlowGraph {
2
  readonly nodes: readonly PivotChartFlowNode[];
3
  readonly edges: readonly PivotChartFlowEdge[];
4
  readonly total: number
5
}

`PivotChartFlowNode`

1
interface PivotChartFlowNode {
2
  readonly id: string;
3
  readonly label: string;
4
  readonly kind: 'category' | 'series';
5
  readonly value: number;
6
  readonly category?: PivotChartCategory;
7
  readonly categoryIndex?: number;
8
  readonly series?: PivotChartSeries;
9
  readonly seriesIndex?: number
10
}

`renderSankey`

1
renderSankey: PivotChartRenderFunction;

`renderCirclePacking`

1
renderCirclePacking: PivotChartRenderFunction;

`renderIcicle`

1
renderIcicle: PivotChartRenderFunction;

`renderSunburst`

1
export function renderSunburst(context: RenderContext);

`renderTreemap`

1
export function renderTreemap(context: RenderContext);

`renderGauge`

1
renderGauge: PivotChartRenderFunction;

`renderKpi`

1
renderKpi: PivotChartRenderFunction;

`renderProgressGauge`

1
renderProgressGauge: PivotChartRenderFunction;

`renderCalendarHeatmap`

1
renderCalendarHeatmap: PivotChartRenderFunction;

`renderHeatmap`

1
renderHeatmap: PivotChartRenderFunction;

`renderMultiRingRadialBar`

1
renderMultiRingRadialBar: PivotChartRenderFunction;

`renderNormalizedPolarColumn`

1
renderNormalizedPolarColumn: PivotChartRenderFunction;

`renderPolarColumn`

1
renderPolarColumn: PivotChartRenderFunction;

`renderRadarArea`

1
renderRadarArea: PivotChartRenderFunction;

`renderRadarLine`

1
renderRadarLine: PivotChartRenderFunction;

`renderRadialBar`

1
renderRadialBar: PivotChartRenderFunction;

`renderRose`

1
renderRose: PivotChartRenderFunction;

`renderStackedPolarColumn`

1
renderStackedPolarColumn: PivotChartRenderFunction;

`renderFunnel`

1
renderFunnel: PivotChartRenderFunction;

`renderPyramid`

1
renderPyramid: PivotChartRenderFunction;

`renderBullet`

1
renderBullet: PivotChartRenderFunction;

`renderConfidenceBand`

1
renderConfidenceBand: PivotChartRenderFunction;

`renderErrorInterval`

1
renderErrorInterval: PivotChartRenderFunction;

`renderLollipop`

1
renderLollipop: PivotChartRenderFunction;

`renderRangeArea`

1
renderRangeArea: PivotChartRenderFunction;

`renderRangeBar`

1
renderRangeBar: PivotChartRenderFunction;

`renderRangeColumn`

1
renderRangeColumn: PivotChartRenderFunction;

`renderWaterfall`

1
renderWaterfall: PivotChartRenderFunction;

`renderBubble`

1
export function renderBubble(context: RenderContext);

`renderConnectedScatter`

1
renderConnectedScatter: PivotChartRenderFunction;

`renderDensityScatter`

1
renderDensityScatter: PivotChartRenderFunction;

`renderHexbin`

1
renderHexbin: PivotChartRenderFunction;

`renderScatter`

1
export function renderScatter(context: RenderContext);

`renderBoxPlot`

1
renderBoxPlot: PivotChartRenderFunction;

`renderRangeInterval`

1
renderRangeInterval: PivotChartRenderFunction;

`renderViolin`

1
renderViolin: PivotChartRenderFunction;

`collectStatisticalData`

1
export function collectStatisticalData(
2
  dataset: PivotChartDataset,
3
  seriesIds?: readonly string[],
4
): StatisticalDatum[];

`createDensitySamples`

1
export function createDensitySamples(
2
  observations: readonly StatisticalObservation[],
3
  requestedSampleCount = 33,
4
): DensitySample[];

`DensitySample`

1
interface DensitySample {
2
  readonly value: number;
3
  readonly density: number
4
}

`StatisticalDatum`

1
interface StatisticalDatum {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly observations: readonly StatisticalObservation[];
5
  readonly count: number;
6
  readonly minimum: number;
7
  readonly lowerQuartile: number;
8
  readonly median: number;
9
  readonly upperQuartile: number;
10
  readonly maximum: number;
11
  readonly mean: number;
12
  readonly lowerWhisker: number;
13
  readonly upperWhisker: number;
14
  readonly outliers: readonly StatisticalObservation[];
15
  readonly representativeSeriesIndex: number
16
}

`StatisticalObservation`

1
interface StatisticalObservation {
2
  readonly value: number;
3
  readonly seriesIndex: number
4
}

`renderTimelineRange`

1
renderTimelineRange: PivotChartRenderFunction;

`renderAnnotatedTimeSeries`

1
renderAnnotatedTimeSeries: PivotChartRenderFunction;

`resolvePivotChartCellContext`

1
export function resolvePivotChartCellContext(
2
  cell?: ContextMenuCellContext,
3
): PivotChartCellContext | undefined;

`PivotChartCellContext`

1
interface PivotChartCellContext {
2
  initialScope: PivotChartInitialScope;
3
  seriesIds: string[];
4
  columnPath: PivotPath;
5
  measure: PivotChartMeasure;
6
  categoryMeasure?: Pick<PivotChartMeasure, 'prop' | 'aggregator'>
7
}

`resolveSpecializedSeriesBindings`

Resolves specialized measure channels only from explicit stable IDs or unambiguous semantic labels. Series position is deliberately never used.

1
export function resolveSpecializedSeriesBindings(
2
  dataset: PivotChartDataset,
3
  current: PivotChartBindings,
4
  requirements: readonly SpecializedBindingRequirement[],
5
): SpecializedBindingResolution;

`resolveMatrixFlowBindings`

1
export function resolveMatrixFlowBindings(
2
  dataset: PivotChartDataset,
3
  current: PivotChartBindings,
4
):;

`boundSeriesIndex`

1
export function boundSeriesIndex(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
  channel: PivotChartBindingChannel,
5
): number | undefined;

`SpecializedSeriesChannel`

1
export type SpecializedSeriesChannel =
2
  | 'low'
3
  | 'high'
4
  | 'open'
5
  | 'close'
6
  | 'volume'
7
  | 'actual'
8
  | 'target'
9
  | 'variance'
10
  | 'start'
11
  | 'end';

`SpecializedBindingRequirement`

1
interface SpecializedBindingRequirement {
2
  channel: SpecializedSeriesChannel;
3
  required: boolean
4
}

`SpecializedBindingResolution`

1
interface SpecializedBindingResolution {
2
  bindings: PivotChartBindings;
3
  missing: SpecializedSeriesChannel[]
4
}

`createPivotChartGeographicRendererInstance`

1
export function createPivotChartGeographicRendererInstance(
2
  pack: Pick<PivotChartGeographicCapabilityPack, 'load'>,
3
  initialInput: PivotChartGeographicRenderInput,
4
): PivotChartGeographicRendererInstance;

`PivotChartDataControls`

1
export function PivotChartDataControls(;

`PivotChartDataTable`

1
export function PivotChartDataTable(;

`PivotChartDataTableLabels`

1
interface PivotChartDataTableLabels {
2
  readonly regionAriaLabel: string;
3
  readonly tableCaption: string;
4
  readonly categoryHeader: string;
5
  readonly hierarchySeparator: string;
6
  readonly emptyValue: string;
7
  readonly formatNumber: (value: number) => string;
8
  readonly sortAscending: (columnLabel: string) => string;
9
  readonly sortDescending: (columnLabel: string) => string;
10
  readonly sortedAscending: (columnLabel: string) => string;
11
  readonly sortedDescending: (columnLabel: string) => string
12
}

`PivotChartDataTableProps`

1
interface PivotChartDataTableProps {
2
  readonly dataset: PivotChartDataset;
3
  readonly labels: PivotChartDataTableLabels
4
}

`PivotChartDialogHeader`

1
export function PivotChartDialogHeader(;

`PivotChartDialogSettings`

1
export function PivotChartDialogSettings(;

`PivotChartDialogTabs`

1
export function PivotChartDialogTabs(;

`PivotChartDialogTab`

1
export type PivotChartDialogTab = 'chart' | 'data' | 'customize';

`PivotChartDialogVisual`

1
export function PivotChartDialogVisual(;

`PIVOT_CHART_THEME_VALUES`

1
PIVOT_CHART_THEME_VALUES: readonly ["auto", "default", "material", "compact", "darkMaterial", "darkCompact"];

`PivotChartPresentationChangeHandler`

1
export type PivotChartPresentationChangeHandler = <
2
  K extends keyof PivotChartPresentation,
3
>(
4
  key: K,
5
  value: PivotChartPresentation[K],
6
) => void;

`PivotChartThemeOption`

1
export type PivotChartThemeOption = readonly [value: string, label: string];

`PivotChartDrillToolbar`

1
export function PivotChartDrillToolbar(;

`PivotChartExportMenu`

1
export function PivotChartExportMenu(;

`PivotChartGallery`

1
export function PivotChartGallery(;

`PivotChartOptionsControls`

1
export function PivotChartOptionsControls(;

`PivotChartPresentationControls`

1
export function PivotChartPresentationControls(;

`PivotChartPreview`

1
export function PivotChartPreview(;

`clearPivotChartPreviewCache`

1
export function clearPivotChartPreviewCache();

`PivotChartRelationshipControls`

1
export function PivotChartRelationshipControls(;

`PivotChartSeriesControl`

1
export function PivotChartSeriesControl(;

`PivotChartThemeControl`

1
export function PivotChartThemeControl(;

`PivotChartTypeControl`

1
export function PivotChartTypeControl(;

`renderAxes`

1
export function renderAxes(
2
  context: RenderContext,
3
  scale: Scale,
4
  horizontal: boolean,
5
  percentage = false,
6
);

`renderXYAxes`

1
export function renderXYAxes(
2
  context: RenderContext,
3
  xScale: Scale,
4
  yScale: Scale,
5
  defaultTitles?:;

`appendCategoryLabel`

1
export function appendCategoryLabel(
2
  context: RenderContext,
3
  category: PivotChartCategory,
4
  categoryIndex: number,
5
  categorySize: number,
6
  horizontal: boolean,
7
  origin?: number,
8
);

`DEFAULT_WIDTH`

1
DEFAULT_WIDTH: 960;

`DEFAULT_HEIGHT`

1
DEFAULT_HEIGHT: 540;

`DEFAULT_PALETTE`

1
DEFAULT_PALETTE: readonly ["#4f8fdc", "#f59e42", "#49a35a", "#38b6d4", "#e7c900", "#8b6fc0", "#e66b77", "#5aa69a"];

`shouldRenderCategoryLabel`

1
export function shouldRenderCategoryLabel(
2
  categoryIndex: number,
3
  categoryCount: number,
4
  categorySize: number,
5
  horizontal: boolean,
6
): boolean;

`shouldRenderDataLabel`

1
export function shouldRenderDataLabel(
2
  categoryIndex: number,
3
  seriesIndex: number,
4
  categoryCount: number,
5
  seriesCount: number,
6
): boolean;

`encodeChartImage`

1
export async function encodeChartImage(
2
  svg: SVGSVGElement,
3
  options: ChartExportSizeOptions,
4
  rendererOptions: PivotChartsRendererOptions,
5
  localeText: PivotChartsLocaleText,
6
);

`encodeChartPdf`

1
export async function encodeChartPdf(
2
  svg: SVGSVGElement,
3
  options: ChartExportSizeOptions,
4
  rendererOptions: PivotChartsRendererOptions,
5
  localeText: PivotChartsLocaleText,
6
);

`normalizeFileName`

1
export function normalizeFileName(
2
  fileName: string | undefined,
3
  fallback: string,
4
  format: PivotChartDownloadFormat,
5
);

`initializeDatumInteractions`

Starts a fresh delegated interaction scope for one SVG render.

Dense charts use a roving tab stop so the chart remains reachable without placing hundreds or thousands of marks in the document tab order.

1
export function initializeDatumInteractions(
2
  svg: SVGSVGElement,
3
  input: PivotChartRenderInput,
4
);

`makeDatumInteractive`

1
export function makeDatumInteractive(
2
  element: SVGElement,
3
  input: PivotChartRenderInput,
4
  category: PivotChartCategory,
5
  series: PivotChartSeries,
6
  value: number | null,
7
  label: string,
8
  description?:;

`getDatumDescription`

1
export function getDatumDescription(element: SVGElement);

`DatumDescription`

1
interface DatumDescription {
2
  readonly category: PivotChartCategory;
3
  readonly series: PivotChartSeries;
4
  readonly value: number | null;
5
  readonly displayValue: string;
6
  readonly title: string;
7
  readonly categoryIndex?: number;
8
  readonly seriesIndex?: number;
9
  readonly channelValues?: PivotChartNodeClick['channelValues'];
10
  readonly channelSeries?: PivotChartNodeClick['channelSeries'];
11
  readonly channelDisplayValues?: Partial<
12
      Record<'x' | 'y' | 'size', string>
13
    >
14
}

`resolveLegendLayout`

1
export function resolveLegendLayout(
2
  width: number,
3
  height: number,
4
  itemCount: number,
5
  position: LegendLayout['position'],
6
): LegendLayout;

`renderLegend`

1
export function renderLegend(
2
  context: RenderContext,
3
  width: number,
4
  height: number,
5
  layout: LegendLayout,
6
  kind: 'series' | 'category',
7
);

`LegendLayout`

1
interface LegendLayout {
2
  readonly position: 'top' | 'right' | 'bottom' | 'left';
3
  readonly columns: number;
4
  readonly itemWidth: number;
5
  readonly visibleItemCount: number;
6
  readonly reservedHeight: number;
7
  readonly reservedWidth: number
8
}

`arcPath`

1
export function arcPath(
2
  centerX: number,
3
  centerY: number,
4
  innerRadius: number,
5
  outerRadius: number,
6
  startAngle: number,
7
  endAngle: number,
8
): string;

`polarPoint`

1
export function polarPoint(
2
  centerX: number,
3
  centerY: number,
4
  radius: number,
5
  angle: number,
6
);

`polarAngle`

1
export function polarAngle(
2
  index: number,
3
  count: number,
4
  offset = -Math.PI / 2,
5
): number;

`renderChart`

1
export function renderChart(
2
  svg: SVGSVGElement,
3
  input: PivotChartRenderInput,
4
  options: PivotChartsRendererOptions,
5
);

`createSvg`

1
export function createSvg<K extends keyof SVGElementTagNameMap>(
2
  document: Document,
3
  name: K,
4
  attributes: Record<string, string | number> =;

`setAttributes`

1
export function setAttributes(
2
  element: Element,
3
  attributes: Record<string, string | number>,
4
);

`appendRect`

1
export function appendRect(
2
  svg: SVGElement,
3
  x: number,
4
  y: number,
5
  width: number,
6
  height: number,
7
  fill: string,
8
  radius = 0,
9
);

`appendLine`

1
export function appendLine(
2
  svg: SVGElement,
3
  x1: number,
4
  y1: number,
5
  x2: number,
6
  y2: number,
7
  stroke: string,
8
);

`appendText`

1
export function appendText(
2
  svg: SVGElement,
3
  x: number,
4
  y: number,
5
  value: string,
6
  attributes: Record<string, string | number>,
7
);

`resolveTheme`

1
export function resolveTheme(
2
  input: Pick<PivotChartRenderInput, 'container' | 'theme'>,
3
): ChartTheme;

`initializeChartTooltip`

1
export function initializeChartTooltip(
2
  svg: SVGSVGElement,
3
  input: PivotChartRenderInput,
4
  options: PivotChartsRendererOptions,
5
  categorySeparator: string,
6
);

`destroyChartTooltip`

1
export function destroyChartTooltip(svg: SVGSVGElement);

`ChartTheme`

1
interface ChartTheme {
2
  background: string;
3
  foreground: string;
4
  muted: string;
5
  grid: string
6
}

`ChartBounds`

1
interface ChartBounds {
2
  left: number;
3
  top: number;
4
  width: number;
5
  height: number
6
}

`Scale`

1
interface Scale {
2
  min: number;
3
  max: number;
4
  position(value: number): number
5
}

`RenderContext`

1
interface RenderContext {
2
  input: PivotChartRenderInput;
3
  svg: SVGSVGElement;
4
  bounds: ChartBounds;
5
  theme: ChartTheme;
6
  palette: readonly string[];
7
  categorySeparator: string
8
}

`PivotChartRenderFunction`

1
export type PivotChartRenderFunction = (context: RenderContext) => void;

`PivotChartTooltipOptions`

1
interface PivotChartTooltipOptions {
2
  /** Delay before a pointer tooltip opens. Keyboard tooltips open immediately. */
3
    showDelayMs?: number;
4
  /** Delay before a pointer tooltip closes. */
5
    hideDelayMs?: number;
6
  /** Keep an open pointer tooltip near the cursor. */
7
    followPointer?: boolean;
8
  /** Additional application class names applied to the tooltip root. */
9
    className?: string;
10
  /** Replaces or refines the default semantic tooltip content. */
11
    formatter?: PivotChartTooltipFormatter
12
}

`assertSupportedType`

1
export function assertSupportedType(
2
  chartType: PivotChartType,
3
  localeText: PivotChartsLocaleText,
4
);

`assertChartShape`

1
export function assertChartShape(
2
  chartType: PivotChartType,
3
  dataset: PivotChartDataset,
4
  localeText: PivotChartsLocaleText,
5
  bindings =;

`assertAlive`

1
export function assertAlive(
2
  destroyed: boolean,
3
  localeText: PivotChartsLocaleText,
4
);

`createValueScale`

1
export function createValueScale(
2
  rows: Array<Array<number | null>>,
3
  stacked: boolean,
4
  length: number,
5
  normalized = false,
6
): Scale;

`createContinuousScale`

1
export function createContinuousScale(
2
  values: readonly number[],
3
  length: number,
4
): Scale;

`normalizeRows`

1
export function normalizeRows(rows: Array<Array<number | null>>);

`cumulativeRows`

1
export function cumulativeRows(rows: Array<Array<number | null>>);

`createStackedRows`

1
export function createStackedRows(rows: Array<Array<number | null>>);

`displayValue`

1
export function displayValue(
2
  dataset: PivotChartDataset,
3
  categoryIndex: number,
4
  seriesIndex: number,
5
  localeText: PivotChartsLocaleText,
6
);

`flattenCategory`

1
export function flattenCategory(
2
  category: PivotChartCategory,
3
  separator: string,
4
);

`formatNumber`

1
export function formatNumber(
2
  value: number | null,
3
  localeText: PivotChartsLocaleText,
4
);

`renderAreaLine`

1
renderAreaLine: PivotChartRenderFunction;

`renderArea`

1
renderArea: PivotChartRenderFunction;

`renderBarChart`

1
export function renderBarChart(
2
  context: RenderContext,
3
  options: BarChartOptions,
4
);

`BarChartOptions`

1
interface BarChartOptions {
2
  readonly orientation: 'horizontal' | 'vertical';
3
  readonly stacking: 'grouped' | 'stacked' | 'normalized'
4
}

`renderColumnLine`

1
renderColumnLine: PivotChartRenderFunction;

`renderCombinationChart`

1
export function renderCombinationChart(
2
  context: RenderContext,
3
  options: CombinationChartOptions,
4
);

`CombinationChartOptions`

1
interface CombinationChartOptions {
2
  readonly primary: 'column' | 'area'
3
}

`renderDonut`

1
renderDonut: PivotChartRenderFunction;

`renderGroupedBar`

1
renderGroupedBar: PivotChartRenderFunction;

`renderGroupedColumn`

1
renderGroupedColumn: PivotChartRenderFunction;

`renderLineAreaChart`

1
export function renderLineAreaChart(
2
  context: RenderContext,
3
  options: LineAreaChartOptions,
4
);

`LineAreaChartOptions`

1
interface LineAreaChartOptions {
2
  readonly area: boolean;
3
  readonly interpolation: LineAreaInterpolation;
4
  readonly stacking: 'none' | 'stacked' | 'normalized'
5
}

`createLinePath`

1
export function createLinePath(
2
  points: readonly LineAreaPoint[],
3
  interpolation: LineAreaInterpolation,
4
): string;

`createAreaPath`

1
export function createAreaPath(
2
  top: readonly LineAreaPoint[],
3
  baseline: readonly LineAreaPoint[],
4
  interpolation: LineAreaInterpolation,
5
): string;

`LineAreaPoint`

1
interface LineAreaPoint {
2
  readonly x: number;
3
  readonly y: number
4
}

`LineAreaInterpolation`

1
export type LineAreaInterpolation = 'linear' | 'smooth' | 'step';

`renderLine`

1
renderLine: PivotChartRenderFunction;

`renderNormalizedArea`

1
renderNormalizedArea: PivotChartRenderFunction;

`renderNormalizedBar`

1
renderNormalizedBar: PivotChartRenderFunction;

`renderNormalizedColumn`

1
renderNormalizedColumn: PivotChartRenderFunction;

`renderPie`

1
renderPie: PivotChartRenderFunction;

`renderPolarChart`

1
export function renderPolarChart(
2
  context: RenderContext,
3
  options: PolarChartOptions,
4
);

`PolarChartOptions`

1
interface PolarChartOptions {
2
  readonly donut: boolean;
3
  readonly startAngle?: number;
4
  readonly sweepAngle?: number;
5
  readonly mark?: string
6
}

`renderSemiDonut`

1
renderSemiDonut: PivotChartRenderFunction;

`renderSmoothLine`

1
renderSmoothLine: PivotChartRenderFunction;

`renderStackedArea`

1
renderStackedArea: PivotChartRenderFunction;

`renderStackedBar`

1
renderStackedBar: PivotChartRenderFunction;

`renderStackedColumn`

1
renderStackedColumn: PivotChartRenderFunction;

`renderSteppedArea`

1
renderSteppedArea: PivotChartRenderFunction;

`renderSteppedLine`

1
renderSteppedLine: PivotChartRenderFunction;

`createWaffleSlices`

1
export function createWaffleSlices(
2
  dataset: PivotChartDataset,
3
  seriesId?: string,
4
  cellCount = 100,
5
): WaffleSlice[];

`WaffleSlice`

1
interface WaffleSlice {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly series: PivotChartSeries;
5
  readonly seriesIndex: number;
6
  readonly value: number;
7
  readonly cells: number
8
}

`collectDistributionData`

1
export function collectDistributionData(
2
  dataset: PivotChartDataset,
3
  seriesId?: string,
4
): DistributionDatum[];

`createHistogramBins`

1
export function createHistogramBins(
2
  data: readonly DistributionDatum[],
3
  requestedBinCount?: number,
4
): HistogramBin[];

`DistributionDatum`

1
interface DistributionDatum {
2
  category: PivotChartCategory;
3
  categoryIndex: number;
4
  series: PivotChartSeries;
5
  seriesIndex: number;
6
  value: number
7
}

`HistogramBin`

1
interface HistogramBin {
2
  index: number;
3
  start: number;
4
  end: number;
5
  count: number;
6
  mean: number;
7
  data: DistributionDatum[]
8
}

`renderPriceSeries`

1
export function renderPriceSeries(
2
  context: RenderContext,
3
  options: PriceRenderOptions,
4
);

`PriceMarkKind`

1
export type PriceMarkKind = 'candlestick' | 'ohlc';

`PriceRenderOptions`

1
interface PriceRenderOptions {
2
  readonly kind: PriceMarkKind;
3
  readonly bounds?: ChartBounds;
4
  readonly attributePrefix: string;
5
  readonly renderAxes?: boolean;
6
  readonly renderCategoryLabels?: boolean
7
}

`collectFinancialData`

1
export function collectFinancialData(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
  requireVolume = false,
5
): FinancialDatum[];

`FinancialDatum`

1
interface FinancialDatum {
2
  readonly categoryIndex: number;
3
  readonly open: number;
4
  readonly high: number;
5
  readonly low: number;
6
  readonly close: number;
7
  readonly volume?: number;
8
  readonly openSeriesIndex: number;
9
  readonly highSeriesIndex: number;
10
  readonly lowSeriesIndex: number;
11
  readonly closeSeriesIndex: number;
12
  readonly volumeSeriesIndex?: number
13
}

`collectHierarchyValues`

1
export function collectHierarchyValues(
2
  dataset: PivotChartDataset,
3
): readonly HierarchyCategoryValue[];

`commonCategoryPrefix`

1
export function commonCategoryPrefix(
2
  categories: readonly PivotChartCategory[],
3
): readonly string[];

`HierarchySeriesValue`

1
interface HierarchySeriesValue {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly series: PivotChartSeries;
5
  readonly seriesIndex: number;
6
  readonly value: number
7
}

`HierarchyCategoryValue`

1
interface HierarchyCategoryValue {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly total: number;
5
  readonly values: readonly HierarchySeriesValue[]
6
}

`renderGaugeChart`

1
export function renderGaugeChart(
2
  context: RenderContext,
3
  options: GaugeOptions,
4
);

`GaugeOptions`

1
interface GaugeOptions {
2
  readonly kind: 'semi' | 'radial';
3
  readonly attributePrefix: string
4
}

`resolveKpiLayouts`

1
export function resolveKpiLayouts(
2
  bounds: ChartBounds,
3
  count: number,
4
): KpiLayout[];

`KpiLayout` (Extended from `kpi-layout.ts`)

1
interface KpiLayout {
2
  readonly index: number
3
}

`collectKpiData`

1
export function collectKpiData(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
): KpiDatum[];

`KpiDatum`

1
interface KpiDatum {
2
  readonly categoryIndex: number;
3
  readonly actual: number;
4
  readonly target: number;
5
  readonly variance: number;
6
  readonly progress: number;
7
  readonly actualSeriesIndex: number;
8
  readonly targetSeriesIndex: number;
9
  readonly varianceSeriesIndex?: number
10
}

`createHeatmapBuckets`

1
export function createHeatmapBuckets(
2
  dataset: PivotChartDataset,
3
  maximumRows: number,
4
  maximumColumns: number,
5
): HeatmapBucket[];

`collectCalendarData`

1
export function collectCalendarData(
2
  dataset: PivotChartDataset,
3
  seriesId?: string,
4
): CalendarDatum[];

`HeatmapBucket`

1
interface HeatmapBucket {
2
  row: number;
3
  column: number;
4
  rowStart: number;
5
  rowEnd: number;
6
  columnStart: number;
7
  columnEnd: number;
8
  count: number;
9
  value: number;
10
  category: PivotChartCategory;
11
  series: PivotChartSeries
12
}

`CalendarDatum`

1
interface CalendarDatum {
2
  category: PivotChartCategory;
3
  categoryIndex: number;
4
  series: PivotChartSeries;
5
  seriesIndex: number;
6
  value: number;
7
  epochDay: number;
8
  day: number;
9
  week: number
10
}

`renderPolarColumnChart`

1
export function renderPolarColumnChart(
2
  context: RenderContext,
3
  options: PolarColumnOptions,
4
);

`PolarColumnMode`

1
export type PolarColumnMode = 'grouped' | 'stacked' | 'normalized';

`PolarColumnOptions`

1
interface PolarColumnOptions {
2
  mode: PolarColumnMode
3
}

`resolvePolarLayout`

1
export function resolvePolarLayout(
2
  context: RenderContext,
3
  labelPadding = 26,
4
): PolarLayout;

`finitePositiveMaximum`

1
export function finitePositiveMaximum(
2
  values: ReadonlyArray<ReadonlyArray<number | null>>,
3
  categoryIndexes?: readonly number[],
4
): number;

`appendPolarGrid`

1
export function appendPolarGrid(
2
  context: RenderContext,
3
  layout: PolarLayout,
4
  axes = true,
5
);

`valueAt`

1
export function valueAt(
2
  context: RenderContext,
3
  categoryIndex: number,
4
  seriesIndex: number,
5
): number | null;

`PolarLayout`

1
interface PolarLayout {
2
  centerX: number;
3
  centerY: number;
4
  radius: number;
5
  categoryIndexes: number[]
6
}

`renderRadarChart`

1
export function renderRadarChart(
2
  context: RenderContext,
3
  options: RadarOptions,
4
);

`RadarOptions`

1
interface RadarOptions {
2
  area: boolean
3
}

`renderRadialBarChart`

1
export function renderRadialBarChart(
2
  context: RenderContext,
3
  options: RadialBarOptions,
4
);

`RadialBarOptions`

1
interface RadialBarOptions {
2
  multiRing: boolean
3
}

`renderProcessChart`

1
export function renderProcessChart(
2
  context: RenderContext,
3
  shape: ProcessShape,
4
);

`createProcessBands`

1
export function createProcessBands(
2
  values: readonly number[],
3
  bounds: ProcessBounds,
4
  shape: ProcessShape,
5
): readonly ProcessBand[];

`ProcessShape`

1
export type ProcessShape = 'funnel' | 'pyramid';

`ProcessBounds`

1
interface ProcessBounds {
2
  readonly left: number;
3
  readonly top: number;
4
  readonly width: number;
5
  readonly height: number
6
}

`ProcessBand`

1
interface ProcessBand {
2
  readonly index: number;
3
  readonly value: number;
4
  readonly top: number;
5
  readonly bottom: number;
6
  readonly topWidth: number;
7
  readonly bottomWidth: number;
8
  readonly points: string
9
}

`collectProcessStages`

1
export function collectProcessStages(
2
  dataset: PivotChartDataset,
3
): readonly ProcessStage[];

`ProcessStage`

1
interface ProcessStage {
2
  readonly category: PivotChartCategory;
3
  readonly categoryIndex: number;
4
  readonly series: PivotChartSeries;
5
  readonly seriesIndex: number;
6
  readonly value: number
7
}

`renderRangeChart`

1
export function renderRangeChart(
2
  context: RenderContext,
3
  options: RangeChartOptions,
4
);

`RangeChartOptions`

1
interface RangeChartOptions {
2
  readonly kind: 'bar' | 'area' | 'interval';
3
  readonly orientation?: 'horizontal' | 'vertical';
4
  readonly valueMode?: RangeValueMode;
5
  readonly attribute: string
6
}

`collectRangeData`

1
export function collectRangeData(
2
  dataset: PivotChartDataset,
3
  bindings: PivotChartBindings,
4
  mode: RangeValueMode = 'bounds',
5
): RangeDatum[];

`RangeDatum`

1
interface RangeDatum {
2
  readonly categoryIndex: number;
3
  readonly lower: number;
4
  readonly upper: number;
5
  readonly center?: number;
6
  readonly lowerSeriesIndex: number;
7
  readonly upperSeriesIndex: number;
8
  readonly centerSeriesIndex?: number
9
}

`RangeValueMode`

1
export type RangeValueMode = 'bounds' | 'centerBounds';

`createDensityBins`

1
export function createDensityBins(
2
  points: readonly DensityPoint[],
3
  radius: number,
4
): DensityBin[];

`DensityPoint`

1
interface DensityPoint {
2
  category: PivotChartCategory;
3
  categoryIndex: number;
4
  xSeries: PivotChartSeries;
5
  xSeriesIndex: number;
6
  ySeries: PivotChartSeries;
7
  ySeriesIndex: number;
8
  x: number;
9
  y: number;
10
  plotX: number;
11
  plotY: number
12
}

`DensityBin`

1
interface DensityBin {
2
  column: number;
3
  row: number;
4
  count: number;
5
  x: number;
6
  y: number;
7
  plotX: number;
8
  plotY: number;
9
  points: DensityPoint[]
10
}

`renderRelationshipChart`

1
export function renderRelationshipChart(
2
  context: RenderContext,
3
  options: RelationshipChartOptions,
4
);

`RelationshipChartOptions`

1
interface RelationshipChartOptions {
2
  bubble: boolean
3
}

`prepareStatisticalChart`

1
export function prepareStatisticalChart(
2
  context: RenderContext,
3
  options?:;

`appendStatisticalCategoryLabels`

1
export function appendStatisticalCategoryLabels(
2
  context: RenderContext,
3
  categorySize: number,
4
);

`statisticalCategoryCenter`

1
export function statisticalCategoryCenter(
2
  context: RenderContext,
3
  categoryIndex: number,
4
  categorySize: number,
5
);

`statisticalValueY`

1
export function statisticalValueY(
2
  context: RenderContext,
3
  scale: StatisticalChartLayout['scale'],
4
  value: number,
5
);

`StatisticalChartLayout`

1
interface StatisticalChartLayout {
2
  readonly data: StatisticalDatum[];
3
  readonly scale: ReturnType<typeof createValueScale>;
4
  readonly categorySize: number
5
}

Pivot Charts

Module Extensions

HTMLRevoGridElement (Extended from global)

HTMLRevoGridElementEventMap (Extended from global)

Plugin API

toPivotChartError

PivotChartErrorCode

PivotChartError

PIVOT_CHART_CREATED_EVENT

PIVOT_CHART_UPDATED_EVENT

PIVOT_CHART_DESTROYED_EVENT

PIVOT_CHART_NODE_CLICK_EVENT

PIVOT_CHART_ERROR_EVENT

PIVOT_CHART_BEFORE_DRILL_EVENT

PIVOT_CHART_DRILL_START_EVENT

PIVOT_CHART_DRILLED_EVENT

PIVOT_CHART_DRILL_ERROR_EVENT

PIVOT_CHART_DRILL_RESET_EVENT

PIVOT_CHART_DRILL_SYNC_EVENT

createPivotChartAnalyticalFrame

ensurePivotChartAnalyticalFrame

PIVOT_CHART_CATEGORY_FIELD_ID

PIVOT_CHART_SERIES_FIELD_ID

getPivotChartDefinition

PivotChartFamily

PivotChartDataChannel

PivotChartChannelRequirement

PivotChartDefinition

PIVOT_CHART_DEFINITIONS

PivotChartType

PIVOT_CHART_TYPES

getPivotChartCatalogExtensionDefinitions

PivotChartCatalogExtensionDefinition

evaluatePivotChartCatalog

evaluatePivotChartCompatibility

resolveRelationshipBindings

PivotChartCompatibilityStatus

PivotChartCompatibilityReason

PivotChartCompatibility

PivotChartCompatibilityContext

createInitialRowDrillState

canDrillIntoCategory

canDrillIntoSeries

canDrillIntoTarget

createRowDrillFrame

appendRowDrillFrame

appendDrillFrame

drillToFrame

getParentDrillState

reconcileDrillState

createRootPivotChartDrillState

parsePivotChartModel

clonePivotChartModel

createPivotChartOptionsSchema

parsePivotChartOptions

resolvePivotChartOption

PivotChartOptionKey

PivotChartBooleanOptionDefinition

PivotChartRangeOptionDefinition

PivotChartOptionDefinition

PivotChartOptionsSchema

projectPivotChartDataset

projectPivotChartSemanticSlice

PIVOT_CHART_MODEL_VERSION

PivotChartTotalsMode

PivotChartTheme

PivotChartUpdateReason

PivotChartLegendPosition

PivotChartAxis

PivotChartDrillSyncMode

PivotChartLimits

DEFAULT_PIVOT_CHART_LIMITS

PivotChartMeasure

PivotChartMeasureSelection

PivotChartMemberKind

PivotChartHierarchyLevel

PivotChartHierarchyDefinition

PivotChartMemberHierarchy

PivotChartCategory

PivotChartSeries