import type { BoxBounds, Callback, CallbackParam, CandidateStyleResolver, CanvasPoint, ChartAnimationPhase, DeepPartial, DistantObject, DomainWithMetadata, DynamicContext, Node, NormalisedChartLabelCollisionOptions, NormalisedColorType, NormalisedDropShadowOptions, NormalisedSeriesMarkerOptions, NormalisedSeriesMarkerStyle, NormalisedSeriesOptions, NormalisedSeriesTooltipOptions, NormalisedTextOrSegments, PlacedLabel, Point, PointLabelDatum, PositionedCandidateResolver, RequireOptional, Selection, SeriesLabelDefaults, SeriesPluginModuleInstance, SizedPoint } from 'ag-charts-core';
import { BBox, ChartAxisDirection, CleanupRegistry, EventEmitter, Group, LRUCache, TranslatableGroup } from 'ag-charts-core';
import type { AgActiveItemState, AgChartLabelFormatterParams, AgDrawingMode, AgInitialStateLegendOptions, AgMatchedParams, AgNodeClickParams, AgNodeContextMenuActionEvent, AgSeriesVisibilityChange, FormatterPropertyType, HighlightState as PublicHighlightState, SelectionState as PublicSelectionState, SeriesType } from 'ag-charts-types';
import type { HighlightChangeEvent, HighlightNodeDatum, LegendItemClickEvent, LegendItemDoubleClickEvent } from '../../core/eventsHub';
import type { ChartRegistry, ChartSeriesRegistry } from '../../module/moduleContext';
import { ModuleMap } from '../../module/moduleMap';
import type { SeriesGrouping } from '../../module/seriesGrouping';
import type { ChartAxis } from '../chartAxis';
import type { ChartMode } from '../chartMode';
import type { DataController } from '../data/dataController';
import type { DataModel, ProcessedData } from '../data/dataModel';
import { DataSet } from '../data/dataSet';
import { type LabelFormatSource } from '../label';
import type { ChartLegendDatum, ChartLegendType } from '../legend/legendDatum';
import type { Marker } from '../marker/marker';
import type { TooltipContent, TooltipStructuredContent } from '../tooltip/tooltip';
import type { PickFocusInputs, PickFocusOutputs, PickNodesInBBoxPredicate, PickResult, PickViewportFocusInputs, SeriesNodePickIntent, SeriesNodePickMatch } from './pickTypes';
import { SeriesNodePickMode } from './pickTypes';
import { type BucketLookupFeature, type DatumIndex, type FireNodeEventParams, HighlightState, type ISeries, type ISeriesAriaMeta, type NodeDataDependencies, SelectionState, type SeriesNodeDatum } from './seriesTypes';
import { type ShapeFillBBox } from './shapeUtil';
type NodeEventType = 'seriesNodeClick' | 'seriesNodeDoubleClick' | 'nodeContextMenuAction';
export interface SeriesDataEvent {
    readonly dataModel: DataModel<any, any, any>;
    readonly processedData: ProcessedData<any>;
}
export type SeriesNodeDataContext<S = SeriesNodeDatum, L = S> = {
    itemId: string;
    nodeData: S[];
    labelData: L[];
};
export type SeriesNodeStyleContext<TStyle> = {
    [HighlightState.None]: TStyle;
    [HighlightState.Item]: TStyle;
    [HighlightState.Series]: TStyle;
    [HighlightState.OtherSeries]: TStyle;
    [HighlightState.OtherItem]: TStyle;
};
/** Cache-miss callback for `runMarkerStylePass` — computes a value keyed by (highlight, selection[, keyExtra]). */
export type MarkerStyleCompute<TSeries, TCtx, TDatum, TCache> = (this: void, series: TSeries, ctx: TCtx, highlightState: HighlightState, selectionState: SelectionState | undefined, datum: TDatum) => TCache;
/** Per-non-garbage-datum callback for `runMarkerStylePass`. */
export type MarkerStyleApply<TSeries, TCtx, TDatum, TCache> = (this: void, series: TSeries, ctx: TCtx, datum: TDatum, highlightState: HighlightState, selectionState: SelectionState | undefined, cached: TCache) => void;
/** Option keys of a series; the bare `object` stands for unknown options and admits any key. */
export type SeriesOptionKey<TOpts extends object> = object extends TOpts ? string : keyof TOpts & string;
export type SeriesDirectionKeysMapping<TOpts extends object> = {
    [key in ChartAxisDirection | FormatterPropertyType]?: SeriesOptionKey<TOpts>[];
};
export declare class SeriesGroupingChangedEvent {
    series: Series<any, any, any>;
    seriesGrouping: SeriesGrouping | undefined;
    constructor(series: Series<any, any, any>, seriesGrouping: SeriesGrouping | undefined);
}
export type SeriesConstructorOpts<TOpts extends object> = {
    moduleCtx: DynamicContext<ChartRegistry>;
    pickModes: SeriesNodePickMode[];
    propertyKeys?: SeriesDirectionKeysMapping<TOpts>;
    propertyNames?: SeriesDirectionKeysMapping<TOpts>;
    canHaveAxes?: boolean;
    usesPlacedLabels?: boolean;
    alwaysClip?: boolean;
    supportsStandaloneZoom?: boolean;
};
export type UnknownSeries = Series<SeriesNodeDatum, object>;
export type SeriesAreaLayout = (series: UnknownSeries[], seriesRect: BBox) => Promise<void>;
export declare abstract class Series<TDatum extends SeriesNodeDatum, TOpts extends object, TLabel = TDatum, TContext extends SeriesNodeDataContext<TDatum, TLabel> = SeriesNodeDataContext<TDatum, TLabel>> implements ISeries<TDatum, NormalisedSeriesOptions<TOpts>, TLabel> {
    static readonly className: string;
    protected cleanup: CleanupRegistry;
    /** Post-theme options, replaced wholesale by {@link applyOptions}; never mutated by the series. */
    options: NormalisedSeriesOptions<TOpts>;
    private _visible;
    pickModes: SeriesNodePickMode[];
    usesPlacedLabels: boolean;
    readonly alwaysClip: boolean;
    /** Opts into StandaloneChart zoom (axis registration + scale/translate viewport). */
    readonly supportsStandaloneZoom: boolean;
    /** Reuses the focused series index for its own navigation (depth, datum type) instead of moving between series. */
    readonly navigatesWithinSeries: boolean;
    readonly supportsDataTransactions: boolean;
    /** Lets the standalone chart round the series area origin down to whole pixels. */
    readonly snapsSeriesAreaOrigin: boolean;
    /** Lays out every series sharing this function, before the chart updates them. */
    readonly seriesAreaLayout?: SeriesAreaLayout;
    protected hasChangesOnHighlight: boolean;
    protected hasChangesOnSelection: boolean;
    get pickModeAxis(): 'main' | 'main-category' | undefined;
    private _seriesGrouping;
    get seriesGrouping(): SeriesGrouping | undefined;
    setSeriesGrouping(seriesGrouping: SeriesGrouping | undefined): void;
    readonly internalId: string;
    get id(): string;
    readonly canHaveAxes: boolean;
    get type(): SeriesType;
    readonly contentGroup: TranslatableGroup<unknown>;
    readonly highlightGroup: TranslatableGroup<unknown>;
    readonly highlightNodeGroup: Group<TDatum>;
    readonly highlightLabelGroup: Group<TLabel>;
    readonly annotationGroup: TranslatableGroup<unknown>;
    readonly labelGroup: TranslatableGroup<TLabel>;
    chart?: {
        mode: ChartMode;
        isMiniChart: boolean;
        flashOnUpdateEnabled: boolean;
        seriesRect?: BBox;
        seriesAreaPadding?: {
            top: number;
            right: number;
            bottom: number;
            left: number;
        };
    };
    axes: {
        [K in ChartAxisDirection]?: ChartAxis;
    };
    directions: ChartAxisDirection[];
    private readonly propertyKeys;
    private readonly propertyNames;
    private _nodeDataRefresh;
    private _nodeDataVersion;
    protected get nodeDataRefresh(): boolean;
    protected set nodeDataRefresh(value: boolean);
    /** Increments on every node-data invalidation; lets consumers skip work while it is unchanged. */
    get nodeDataVersion(): number;
    /** Re-solves this series' labels for an input that lives outside its node data, such as its layout. */
    protected invalidateLabelPlacement(): void;
    protected processedDataUpdated: boolean;
    protected readonly moduleMap: ModuleMap<SeriesPluginModuleInstance>;
    protected _data?: DataSet<any>;
    protected _chartData?: DataSet<any>;
    private _dataConnected;
    private readonly datumCallbackCache;
    /** Compiled-format caches keyed by label options object; replaced options simply start a new entry. */
    private readonly labelFormatters;
    private readonly compiledLabelFormats;
    private legendItemName?;
    private legendItemKey?;
    connectsToYAxis: boolean;
    get focusable(): boolean;
    get data(): DataSet<any> | undefined;
    set visible(newVisibility: boolean);
    get visible(): boolean;
    get hasData(): boolean;
    get tooltipEnabled(): boolean | undefined;
    /** Replaces the series options; `diff` holds only the changed keys, `undefined` on the initial apply. */
    applyOptions(options: NormalisedSeriesOptions<TOpts>, diff?: DeepPartial<NormalisedSeriesOptions<TOpts>>): void;
    /** Hook for state a series derives from its options (caches, dirty flags); see {@link applyOptions}. */
    protected syncOptionDerivedState(_diff: DeepPartial<NormalisedSeriesOptions<TOpts>> | undefined): void;
    protected onDataChange(): void;
    setOptionsData(input: DataSet | undefined): void;
    isHighlightEnabled(): boolean;
    isSelectionEnabled(): boolean;
    isDatumSelectable(_datumIndex: DatumIndex): boolean;
    /** Whether pointer hover can pick this series' nodes, for highlights and tooltips alike; clicks still can. */
    protected isHoverable(): boolean;
    /** Series returning the same group select and deselect their items of a shared category together. */
    getSelectionGroup(): string | undefined;
    setChartData(input: DataSet | undefined): void;
    private onSeriesGroupingChange;
    getBandScalePadding(): {
        inner: number;
        outer: number;
    };
    readonly ctx: DynamicContext<ChartRegistry>;
    private moduleContext?;
    constructor(seriesOpts: SeriesConstructorOpts<TOpts>);
    attachSeries(seriesContentNode: Group, seriesNode: Group, _annotationNode: Group | undefined): void;
    detachSeries(_seriesContentNode: Group | undefined, _seriesNode: Group, _annotationNode: Group | undefined): void;
    declarationOrder: number;
    private _broughtToFront;
    setSeriesIndex(index: number, forceUpdate?: boolean): boolean;
    setZIndex(zIndex: number): void;
    renderToOffscreenCanvas(): boolean;
    disconnectData(): void;
    reconnectData(): void;
    protected hasHighlightOpacity(): boolean;
    /** The chart-level `highlight` options. */
    protected getChartHighlightOptions(): import("ag-charts-types").AgChartHighlightOptions | undefined;
    protected getChartHighlightDrawingMode(): AgDrawingMode;
    protected getDrawingMode(isHighlight?: boolean, highlightDrawingMode?: AgDrawingMode): AgDrawingMode;
    protected getAnimationDrawingModes(): {
        start: {
            drawingMode: AgDrawingMode;
        };
        finish: {
            drawingMode: AgDrawingMode;
        };
    };
    readonly events: EventEmitter<{
        'data-update': SeriesDataEvent;
        'data-processed': SeriesDataEvent;
        'data-selection-change': null;
        'grouping-changed': SeriesGroupingChangedEvent;
        'visibility-change': AgSeriesVisibilityChange;
    }>;
    updatedDomains(): void;
    destroy(): void;
    abstract resetAnimation(chartAnimationPhase: ChartAnimationPhase): void;
    private getPropertyValues;
    getKeyAxis(_direction: ChartAxisDirection): string | undefined;
    getKeys(direction: ChartAxisDirection): string[];
    getKeyProperties(direction: ChartAxisDirection): SeriesOptionKey<TOpts>[];
    getNames(direction: ChartAxisDirection): (string | undefined)[];
    getFormatterContext(property: FormatterPropertyType): Array<{
        seriesId: string;
        key: string;
        name: string | undefined;
    }>;
    resolveKeyDirection(direction: ChartAxisDirection): ChartAxisDirection;
    getDomain(direction: ChartAxisDirection): DomainWithMetadata<any>;
    getRange(direction: ChartAxisDirection, visibleRange: [number, number]): [number, number] | [];
    getMinimumRangeSeries(_range: number[]): void;
    getMinimumRangeChart(_ranges: number[]): number;
    /** The chart's data set when this series needs more than a flat one. */
    createChartDataSet(_data: unknown[], _dataIdKey: string | undefined): DataSet | undefined;
    /** The chart's accessible name when this series type announces it differently from its chart. */
    getChartAriaLabel(_caption: string, _series: readonly UnknownSeries[]): string | undefined;
    getZoomRangeFittingItems(_xVisibleRange: [number, number], _yVisibleRange: [number, number] | undefined, _minVisibleItems: number): {
        x: [number, number];
        y: [number, number] | undefined;
    } | undefined;
    getVisibleItems(_xVisibleRange: [number, number], _yVisibleRange: [number, number] | undefined, _minVisibleItems: number): number;
    abstract dataCount(): number;
    abstract getSeriesDomain(direction: ChartAxisDirection): DomainWithMetadata<any>;
    abstract getSeriesRange(direction: ChartAxisDirection, visibleRange: [number, number]): [number, number] | [];
    abstract processData(dataController: DataController): Promise<void> | void;
    abstract createNodeData(): TContext | undefined;
    abstract findNodeDatum(itemIdOrIndex: AgActiveItemState['itemId']): SeriesNodeDatum | undefined;
    toCanvasFromMidPoint(nodeDatum: {
        midPoint?: Point;
    }): CanvasPoint;
    markNodeDataDirty(): void;
    private getSeriesWidth;
    private visibleMaybeChanged;
    abstract update(opts: {
        seriesRect?: BBox;
    }): Promise<void> | void;
    getOpacity(): number;
    getHighlightState(highlightedDatum: HighlightNodeDatum | undefined, isHighlight?: boolean, datumIndex?: DatumIndex, legendItemValues?: string[]): HighlightState;
    /**
     * In `highlight.mode: 'shared'`, the index of this series' item sharing the highlighted datum's category.
     * `undefined` when there is none, for series-level highlights, and for the hovered series itself.
     */
    private getSharedCategoryMatch;
    getDataSelectionState(datumIndex: DatumIndex | undefined): SelectionState | undefined;
    getDataCandidacyState(datumIndex: DatumIndex | undefined): SelectionState | undefined;
    /**
     * Per-series aggregation-aware bucket lookup. Optional — populated
     * lazily for aggregating series only. Owns both the per-bucket SELECTED
     * roll-up and the bucket→datum-range mapping used by the data-selection
     * drag handler. `DataModelSeries.getDataSelectionState` consults this
     * for marker styling; `data-selection-change` and aggregation rebuilds
     * keep the roll-up in sync.
     */
    protected bucketLookup?: BucketLookupFeature;
    /**
     * Construct the series-specific {@link BucketLookupFeature}. Default
     * `undefined` for non-aggregating series. Aggregating series override to
     * return either {@link BucketLookupManager} (single `indexData`) or
     * {@link SplitBucketLookupManager} (split positive/negative).
     */
    protected createBucketLookupFeature(): BucketLookupFeature | undefined;
    /**
     * Lazy-init `bucketLookup` on first access. The just-created feature is
     * refreshed once so it reflects the current selection bitset and
     * aggregation filters — without this any `filtersChanged` events emitted
     * before the lazy-init would have been missed.
     */
    ensureBucketLookupFeature(): BucketLookupFeature | undefined;
    getHighlightStateString(datum: HighlightNodeDatum | undefined, isHighlight?: boolean, datumIndex?: DatumIndex, legendItemValues?: string[]): PublicHighlightState;
    getSelectionStateString(datumIndex: DatumIndex | undefined, selectionState?: SelectionState): PublicSelectionState | undefined;
    getCandidateStateString(datumIndex: DatumIndex | undefined, candidateState?: SelectionState): PublicSelectionState | undefined;
    getCollapsedState(_itemId: string | number): boolean | undefined;
    protected onChangeHighlight(event: HighlightChangeEvent): void;
    bringToFront(): boolean;
    isSeriesHighlighted(highlightedDatum: HighlightNodeDatum | undefined, _legendItemValues?: string[]): boolean;
    /** The `glow` of each highlight state as a shadow, which `applyOptions` drops. `null` once resolved to none. */
    private glowByState?;
    private getStateGlow;
    /** Whether any highlight state sets an enabled `glow`; when none does, the shadow is never resolved per datum. */
    private anyGlow?;
    private hasAnyGlow;
    /**
     * The shadow to draw on one copy of an item. A hovered item is drawn twice: in place, and again by the highlight
     * layer on top of it. The highlight layer's copy casts only the `glow` of the hovered item, centred on it and above
     * every series. Every in-place copy casts the item's own `shadow` in the base pass that keeps it behind every
     * series, except where its highlight state sets a `glow`: that glow replaces the shadow, as an item has one shadow
     * slot. The exception is the item this series' highlight layer redraws, whose in-place copy keeps its `shadow`.
     * AG-9003: while no `glow` is set, every copy casts its `shadow`, as in 14.2.0.
     */
    protected resolveItemShadow(shadow: NormalisedDropShadowOptions | undefined, isHighlight: boolean | undefined, datumIndex?: DatumIndex, highlightState?: HighlightState, legendItemValues?: string[]): NormalisedDropShadowOptions | undefined;
    /** The redrawn index of the active highlight, read once per highlight rather than per datum. */
    private redrawnPass?;
    /** For a series whose `getRedrawnDatumIndex` reads state that changes between updates, such as its data. */
    protected resetRedrawnIndex(): void;
    private getRedrawnIndex;
    /**
     * The index of the item this series' highlight layer redraws over its in-place copy, if `highlightedDatum` is one.
     * A series that draws no highlight copy for an item it reports as highlighted overrides this, as the in-place copy
     * of that item must keep casting its shadow.
     */
    protected getRedrawnDatumIndex(highlightedDatum: HighlightNodeDatum | undefined): DatumIndex | undefined;
    protected isItemHighlighted(highlightedDatum?: HighlightNodeDatum, datumIndex?: DatumIndex): boolean | undefined;
    protected isDatumHighlight(highlightedDatum: HighlightNodeDatum | undefined): boolean;
    private hasDataSelection;
    getHighlightStyle(isHighlight?: boolean, datumIndex?: DatumIndex, highlightState?: HighlightState, legendItemValues?: string[]): ReturnType<typeof this.resolveHighlightStyle>;
    /** The `glow` of a highlight state, which {@link getHighlightStyle} leaves out, through the same cascade. */
    getHighlightGlow(highlightState: HighlightState): {
        enabled?: boolean | undefined;
        fill?: import("ag-charts-types").CssColor | undefined;
        fillOpacity?: import("ag-charts-types").Opacity | undefined;
        blur?: import("ag-charts-types").PixelSize | undefined;
        spread?: import("ag-charts-types").PixelSize | undefined;
    } | undefined;
    private resolveHighlightStyle;
    /** The merged highlight style of each state, which `applyOptions` drops. Callers must not modify it. */
    private highlightStyleByState?;
    getSelectionStyle(datumIndex?: DatumIndex, selectionState?: SelectionState, candidateState?: SelectionState): Partial<import("ag-charts-core").NormalisedSeriesOwnOptions<TOpts> & import("ag-charts-core").NormalisedSeriesStateStyle> | undefined;
    protected resolveMarkerDrawingModeForState(drawingMode: AgDrawingMode, style?: NormalisedSeriesMarkerStyle): AgDrawingMode;
    protected abstract hasItemStylers(): boolean;
    filterItemStylerFillParams(fill: NormalisedColorType | undefined): NormalisedColorType | undefined;
    protected getModuleTooltipParams(): object;
    abstract getTooltipContent(datumIndex: DatumIndex, removeThisDatum: TDatum | undefined): TooltipContent | undefined;
    getDatumAriaMeta(_seriesDatum: TDatum, _description: string): ISeriesAriaMeta | undefined;
    /** Whether the series currently has drawn node shapes for `EXACT_SHAPE_MATCH` to resolve against. */
    protected hasPickableNodeShapes(): boolean;
    protected _pickNodeCache: LRUCache<PickResult | undefined, string>;
    pickNodes(point: Point, intent: SeriesNodePickIntent, exactMatchOnly?: boolean): PickResult | undefined;
    protected pickNodesExactShape(point: Point): SeriesNodePickMatch[];
    protected pickNodeClosestDatum(_point: Point): SeriesNodePickMatch | undefined;
    pickNodeNearestDistantObject<T extends Node & DistantObject>(point: Point, items: Iterable<T>): SeriesNodePickMatch | undefined;
    protected pickNodeMainAxisFirst(_point: Point, _requireCategoryAxis: boolean): SeriesNodePickMatch | undefined;
    hasBuiltinListener(_target: Node<unknown> | undefined): boolean;
    /**
     * Names the part of a node the given scene node belongs to, for series that render more than one
     * distinct part per node (e.g. the org-chart card and its expander pill).
     *
     * The returned value rides along with the highlight selection, so a series can tell *which* part of
     * the highlighted node the pointer is over. Highlight roll-up is unaffected: the highlighted datum
     * is the same either way, and only a series returning a non-`undefined` part makes the highlight
     * sensitive to the distinction.
     */
    getHighlightPart(_target: Node<unknown> | undefined): string | undefined;
    firesUserClickListeners(_target: Node<unknown> | undefined): boolean;
    protected pickNodesInBBoxPredicate(): PickNodesInBBoxPredicate;
    pickNodesInBBox(selectionBox: BoxBounds): Iterable<TDatum>;
    isPointInArea?(x: number, y: number): boolean;
    getLabelData(): PointLabelDatum[];
    getLabelDefaults(): SeriesLabelDefaults | undefined;
    getLabelCandidateStyler(): CandidateStyleResolver | undefined;
    getLabelCandidateResolver(): PositionedCandidateResolver | undefined;
    updatePlacedLabelData(_labels: PlacedLabel<TLabel>[]): void;
    hasNodeListener(type: 'seriesNodeClick' | 'seriesNodeDoubleClick'): boolean;
    private callListeners;
    fireNodeClickEvent(opts: FireNodeEventParams): boolean;
    fireNodeDoubleClickEvent(opts: FireNodeEventParams): boolean;
    createNodeContextMenuActionEvent(opts: FireNodeEventParams): AgNodeContextMenuActionEvent;
    createNodeEvent<T extends NodeEventType>(type: T, opts: FireNodeEventParams): {
        type: T;
        event: Event;
        coordinates: import("ag-charts-types").AgCoordinates | undefined;
        allMatchedParams: AgMatchedParams<unknown>[];
        defaultPrevented: boolean;
        preventDefault: () => void;
        seriesId: string;
        itemId: string | number;
        dataIdKey?: string | undefined;
        datum: unknown;
        datums?: unknown[] | undefined;
        itemType?: import("ag-charts-types").AgItemType;
        totalValue?: import("ag-charts-types").AgNumericValue;
        selectionState?: PublicSelectionState;
        isCollapsed?: boolean;
        xKey?: string | undefined;
        yKey?: string | undefined;
        sizeKey?: string | undefined;
        labelKey?: string | undefined;
        colorKey?: string | undefined;
        angleKey?: string | undefined;
        calloutLabelKey?: string | undefined;
        sectorLabelKey?: string | undefined;
        radiusKey?: string | undefined;
        binIndex?: number;
        binRange?: [import("ag-charts-types").AgNumericValue, import("ag-charts-types").AgNumericValue];
        aggregatedValue?: import("ag-charts-types").AgNumericValue;
        frequency?: number;
    };
    createNodeParams(datum: TDatum): Omit<AgNodeClickParams<unknown>, 'type'>;
    onLegendInitialState(legendType: ChartLegendType, initialState: AgInitialStateLegendOptions | undefined): void;
    onLegendItemClick(event: LegendItemClickEvent): void;
    onLegendItemDoubleClick(event: LegendItemDoubleClickEvent): void;
    /** Series linked by `legendItemKey` can order their rows differently, so the clicked row is matched by name. */
    private findLinkedLegendItemId;
    abstract getLegendData<T extends ChartLegendType>(legendType: T): ChartLegendDatum<T>[];
    abstract getLegendData(legendType: ChartLegendType): ChartLegendDatum<ChartLegendType>[];
    protected toggleSeriesItem(enabled: boolean, legendType: ChartLegendType, itemId: string | number | undefined, legendItemName: string | undefined, legendEvent?: {
        legendItemName?: string;
    }): void;
    isEnabled(): boolean;
    getModuleMap(): ModuleMap<SeriesPluginModuleInstance>;
    createModuleContext(): DynamicContext<ChartSeriesRegistry>;
    protected getAxisValueText(axis: ChartAxis, source: 'tooltip', value: any, datum: any, key: string, legendItemName: string | undefined, allowNull?: boolean): string;
    /** Plain label options are wrapped once per options object so the compiled format string is reused. */
    private labelFormatterFor;
    protected getLabelText<TParams extends object>(value: any, datum: any, key: string, property: FormatterPropertyType, domain: any[], labelSource: LabelFormatSource<TParams, any>, baseParams: RequireOptional<TParams> & Omit<AgChartLabelFormatterParams<any>, 'seriesId'>, allowNullValue?: boolean): NormalisedTextOrSegments;
    getMarkerStyle<TParams>(marker: NormalisedSeriesMarkerOptions<TParams>, { datumIndex, datum, point }: Partial<TDatum>, params?: TParams, opts?: {
        highlightState?: HighlightState;
        /** Pre-resolved by per-datum hot paths to skip the getDataSelectionState() lookup. */
        selectionState?: SelectionState;
        isHighlight?: boolean;
        checkForHighlight?: boolean;
        resolveMarkerSubPath?: string[];
        resolveStyler?: boolean;
        hideWithSize0?: boolean;
    }, defaultOverrideStyle?: NormalisedSeriesMarkerStyle & {
        size: number;
    }, inheritedStyle?: NormalisedSeriesMarkerStyle): Omit<import("ag-charts-types").AgSeriesMarkerStyle, keyof import("ag-charts-core").FillStrokeMorph> & import("ag-charts-core").FillStrokeMorph & {} & {
        size: number;
        opacity?: number;
    };
    protected applyMarkerStyle(style: NormalisedSeriesMarkerStyle, markerNode: Marker, point: SizedPoint | undefined, fillBBox: ShapeFillBBox | undefined, opts: {
        applyPosition?: boolean;
        crossFilterSelected?: boolean;
        hideWithSize0: boolean;
        /** Floor for `Marker.pickInflation`, from `maxMarkerStrokePickInflation` (AG-8173). */
        pickInflation?: number;
        /** The marker's `shadow` option; not part of the per-datum style, as nothing can vary it per datum. */
        shadow?: NormalisedDropShadowOptions;
        /** Whether this is the highlight layer's copy, which casts the hovered item's `glow` instead of the `shadow`. */
        isHighlight?: boolean;
        /** With `isHighlight`, picks the `glow` of the highlight state this marker is drawn in. */
        datumIndex?: DatumIndex;
        /** The marker's highlight state when the caller has already resolved it. */
        highlightState?: HighlightState;
    }): void;
    applyFocusSize(markerBBox: BBox, style: NormalisedSeriesMarkerStyle, point: SizedPoint | undefined): void;
    /**
     * Per-datum marker-style pass with a state-keyed cache, shared across all marker-rendering series.
     * Callbacks take `series` and `ctx` explicitly so callers pass static methods (stable function
     * identity) and keep V8's inline cache monomorphic across series sharing this helper.
     *
     * @param opts.keyExtra - optional extra cache-key dimension (e.g. range-area's `datum.itemType`)
     * @param opts.cacheable - set false when `compute` returns a value mutated per datum (e.g. bubble + colorScale)
     * @param opts.compute - called once per distinct (highlight, selection[, keyExtra]) tuple
     * @param opts.apply - called per non-garbage datum with the cached value
     */
    protected runMarkerStylePass<TCtx, TPassDatum extends SeriesNodeDatum, TCache, TSeries = this>(datumSelection: Selection<TPassDatum, Marker<TPassDatum>>, isHighlight: boolean, ctx: TCtx, opts: {
        keyExtra?: (datum: TPassDatum) => string;
        cacheable?: boolean;
        compute: MarkerStyleCompute<TSeries, TCtx, TPassDatum, TCache>;
        apply: MarkerStyleApply<TSeries, TCtx, TPassDatum, TCache>;
    }): void;
    /** Default `apply` for the no-itemStyler path — writes the cached style straight onto the datum. */
    protected static readonly assignCachedStyle: MarkerStyleApply<unknown, unknown, {
        style?: unknown;
    }, unknown>;
    /**
     * The series plot area as a label containment rect, in plot-local coordinates, so the
     * seriesArea padding extends the rect into a negative origin. A label overflowing this rect
     * spills past the series area (into the axis/padding zone) and must fail collision containment.
     */
    protected getSeriesPlotRegion(): BoxBounds | undefined;
    /** The plot-area containment rect when the label opts into `collideWith.seriesArea`, else `undefined`. */
    protected resolveLabelPlotRegion(collision: NormalisedChartLabelCollisionOptions): BoxBounds | undefined;
    protected _nodeDataDependencies?: NodeDataDependencies;
    get nodeDataDependencies(): NodeDataDependencies;
    protected checkResize(newSeriesRect?: BBox): boolean;
    pickFocus(_opts: PickFocusInputs): PickFocusOutputs | undefined;
    pickViewportFocus(_opts: PickViewportFocusInputs): PickFocusOutputs | undefined;
    /** Drops every cached datum callback result, or only the one cached under `id`. */
    resetDatumCallbackCache(id?: unknown): void;
    cachedDatumCallback<T>(id: any, fn: () => T): T | undefined;
    cachedCallWithContext<F extends Callback>(fn: F, params: CallbackParam<F>, cacheKey?: string): ReturnType<F> | undefined;
    callWithContext<F extends Callback>(fn: F, params: CallbackParam<F>): ReturnType<F>;
    protected formatTooltipWithContext<P>(tooltip: NormalisedSeriesTooltipOptions<P>, content: TooltipStructuredContent, params: P): TooltipContent;
    abstract getCategoryValue(datumIndex: DatumIndex): any;
    abstract datumIndexForCategoryValue(categoryValue: any): DatumIndex | undefined;
    minTimeInterval(): number | undefined;
    needsDataModelDiff(): boolean;
}
export {};