Aggrid custom

node_modules/ag-charts-enterprise/dist/types/src/axes/angle-category/angleCategoryAxis.d.ts

@@ -0,0 +1,20 @@
+import { type FormatterParams, _ModuleSupport } from 'ag-charts-community';
+import { AngleAxisInterval } from '../angle-number/angleAxisInterval';
+import type { AngleAxisLabelDatum } from '../angle/angleAxis';
+import { AngleAxis } from '../angle/angleAxis';
+export declare class AngleCategoryAxis extends AngleAxis<string, _ModuleSupport.BandScale<string>> {
+    static readonly className = "AngleCategoryAxis";
+    static readonly type: "angle-category";
+    groupPaddingInner: number;
+    paddingInner: number;
+    interval: AngleAxisInterval;
+    constructor(moduleCtx: _ModuleSupport.ModuleContext);
+    hasDefinedDomain(): boolean;
+    protected generateAngleTicks(domain: string[]): {
+        value: any;
+        visible: boolean;
+    }[];
+    protected avoidLabelCollisions(labelData: AngleAxisLabelDatum[]): void;
+    tickFormatParams(): _ModuleSupport.AxisTickFormatParams;
+    datumFormatParams(value: any, params: _ModuleSupport.FormatDatumParams): FormatterParams<any>;
+}

node_modules/ag-charts-enterprise/dist/types/src/axes/angle-category/angleCategoryAxisModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgAngleCategoryAxisOptions } from 'ag-charts-community';
+import type { AxisModuleDefinition } from 'ag-charts-core';
+export declare const AngleCategoryAxisModule: AxisModuleDefinition<AgAngleCategoryAxisOptions>;

node_modules/ag-charts-enterprise/dist/types/src/axes/angle-number/angleAxisInterval.d.ts

@@ -0,0 +1,6 @@
+import { _ModuleSupport } from 'ag-charts-community';
+declare const AxisInterval: typeof _ModuleSupport.AxisInterval;
+export declare class AngleAxisInterval extends AxisInterval<number> {
+    minSpacing?: number;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/axes/angle-number/angleNumberAxis.d.ts

@@ -0,0 +1,32 @@
+import { type FormatterParams, _ModuleSupport } from 'ag-charts-community';
+import type { DomainWithMetadata } from 'ag-charts-core';
+import type { AngleAxisLabelDatum } from '../angle/angleAxis';
+import { AngleAxis } from '../angle/angleAxis';
+import { AngleAxisInterval } from './angleAxisInterval';
+import { LinearAngleScale } from './linearAngleScale';
+export declare class AngleNumberAxis extends AngleAxis<number, LinearAngleScale> {
+    static readonly className = "AngleNumberAxis";
+    static readonly type: "angle-number";
+    shape: "circle";
+    min?: number;
+    max?: number;
+    preferredMin?: number;
+    preferredMax?: number;
+    interval: AngleAxisInterval;
+    constructor(moduleCtx: _ModuleSupport.ModuleContext);
+    hasDefinedDomain(): boolean;
+    normaliseDataDomain(d: DomainWithMetadata<number>): {
+        domain: number[];
+        clipped: boolean;
+    };
+    getDomainExtentsNice(): [boolean, boolean];
+    updateScale(): void;
+    protected getRangeArcLength(): number;
+    protected generateAngleTicks(domain: number[]): {
+        value: number;
+        visible: boolean;
+    }[];
+    protected avoidLabelCollisions(labelData: AngleAxisLabelDatum[]): void;
+    tickFormatParams(_domain: number[], _ticks: number[], fractionDigits?: number): _ModuleSupport.AxisTickFormatParams;
+    datumFormatParams(value: any, params: _ModuleSupport.FormatDatumParams, fractionDigits?: number): FormatterParams<any>;
+}

node_modules/ag-charts-enterprise/dist/types/src/axes/angle-number/angleNumberAxisModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgAngleNumberAxisOptions } from 'ag-charts-community';
+import type { AxisModuleDefinition } from 'ag-charts-core';
+export declare const AngleNumberAxisModule: AxisModuleDefinition<AgAngleNumberAxisOptions>;

node_modules/ag-charts-enterprise/dist/types/src/axes/angle-number/linearAngleScale.d.ts

@@ -0,0 +1,18 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { type ScaleTickParams } from 'ag-charts-core';
+declare const LinearScale: typeof _ModuleSupport.LinearScale;
+export declare class LinearAngleScale extends LinearScale {
+    static getNiceStepAndTickCount(ticks: ScaleTickParams<number>, domain: number[]): {
+        count: number;
+        step: number;
+    };
+    arcLength: number;
+    ticks(ticks: ScaleTickParams<number>, domain?: number[]): {
+        ticks: number[];
+        count: number;
+    };
+    private hasNiceRange;
+    niceDomain(ticks: ScaleTickParams<number>, domain?: number[]): number[];
+    protected getPixelRange(): number;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/axes/angle/angleAxis.d.ts

@@ -0,0 +1,93 @@
+import type { AgAngleAxisLabelOrientation, TextOrSegments } from 'ag-charts-community';
+import { _ModuleSupport } from 'ag-charts-community';
+import { ChartAxisDirection, type Scale } from 'ag-charts-core';
+export interface AngleAxisLabelDatum {
+    text: TextOrSegments;
+    x: number;
+    y: number;
+    hidden: boolean;
+    rotation: number;
+    textAlign: CanvasTextAlign;
+    textBaseline: CanvasTextBaseline;
+    box: _ModuleSupport.BBox | undefined;
+}
+interface AngleAxisTickDatum<TDatum> {
+    value: TDatum;
+    visible: boolean;
+}
+declare class AngleAxisLabel extends _ModuleSupport.AxisLabel {
+    orientation: AgAngleAxisLabelOrientation;
+}
+export declare abstract class AngleAxis<TDomain, TScale extends Scale<TDomain, any>> extends _ModuleSupport.PolarAxis<TScale> {
+    protected static CrossLineConstructor: new () => _ModuleSupport.CrossLine<any>;
+    startAngle: number;
+    endAngle: number | undefined;
+    protected tickLineGroupSelection: _ModuleSupport.Selection<_ModuleSupport.Line, AngleAxisTickDatum<TDomain>>;
+    protected gridLineGroupSelection: _ModuleSupport.Selection<_ModuleSupport.Line, AngleAxisTickDatum<TDomain>>;
+    protected labelData: AngleAxisLabelDatum[];
+    protected tickData: AngleAxisTickDatum<TDomain>[];
+    protected radiusLineGroup: _ModuleSupport.TransformableGroup;
+    protected radiusLine: _ModuleSupport.Path;
+    constructor(moduleCtx: _ModuleSupport.ModuleContext, scale: TScale);
+    get direction(): ChartAxisDirection;
+    protected createLabel(): AngleAxisLabel;
+    calculateRotations(): {
+        rotation: number;
+        parallelFlipRotation: number;
+        regularFlipRotation: number;
+    };
+    calculateTickLayout(domain: TDomain[]): {
+        niceDomain: any[];
+        tickDomain: TDomain[];
+        ticks: TDomain[];
+        rawTickCount: number | undefined;
+        fractionDigits: number;
+        timeInterval: undefined;
+        bbox: _ModuleSupport.BBox;
+    };
+    update(): void;
+    private normalizedAngles;
+    computeRange(): void;
+    protected abstract generateAngleTicks(domain: TDomain[]): AngleAxisTickDatum<TDomain>[];
+    protected updateSelections(): void;
+    updatePosition(): void;
+    protected updateRadiusLine(): void;
+    getAxisLinePoints(): {
+        points: ({
+            x: number;
+            y: number;
+            moveTo: boolean;
+            radius?: undefined;
+            startAngle?: undefined;
+            endAngle?: undefined;
+            arc?: undefined;
+        } | {
+            x: number;
+            y: number;
+            radius: number;
+            startAngle: number;
+            endAngle: number;
+            arc: boolean;
+            moveTo: boolean;
+        })[];
+        closePath: boolean;
+    };
+    private updateGridLines;
+    protected updateLabels(): void;
+    private updateTickLines;
+    protected createLabelNodeData(ticks: any[], options: {
+        hideWhenNecessary: boolean;
+    }, seriesRect: _ModuleSupport.BBox): AngleAxisLabelDatum[];
+    protected abstract avoidLabelCollisions(labelData: AngleAxisLabelDatum[]): void;
+    computeLabelsBBox(options: {
+        hideWhenNecessary: boolean;
+    }, seriesRect: _ModuleSupport.BBox): _ModuleSupport.BBox | null;
+    protected getLabelOrientation(): AgAngleAxisLabelOrientation;
+    protected getLabelRotation(tickAngle: number): number;
+    protected getLabelAlign(tickAngle: number): {
+        textAlign: "left" | "right" | "center";
+        textBaseline: "top" | "bottom" | "middle";
+    };
+    protected updateCrossLines(): void;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/axes/ordinal/ordinalTimeAxis.d.ts

@@ -0,0 +1,19 @@
+import { type AgTimeInterval, type AgTimeIntervalUnit, type DateFormatterStyle, type FormatterParams, _ModuleSupport } from 'ag-charts-community';
+export declare class OrdinalTimeAxis extends _ModuleSupport.DiscreteTimeAxis<_ModuleSupport.OrdinalTimeScale> {
+    static readonly className: "OrdinalTimeAxis";
+    static readonly type: "ordinal-time";
+    readonly parentLevel: _ModuleSupport.TimeAxisParentLevel;
+    private readonly accurateScale;
+    private readonly approximateScale;
+    get primaryLabel(): _ModuleSupport.AxisLabel | undefined;
+    get primaryTick(): _ModuleSupport.AxisTick | undefined;
+    constructor(moduleCtx: _ModuleSupport.ModuleContext);
+    /**
+     * Returns the active scale based on visible range and data uniformity.
+     * Use approximate scale when data is uniform and visible datum count is large.
+     */
+    getActiveScale(): _ModuleSupport.OrdinalTimeScale;
+    processData(): void;
+    tickFormatParams(domain: (number | Date)[], ticks: (number | Date)[], _fractionDigits?: number, timeInterval?: AgTimeInterval | AgTimeIntervalUnit): _ModuleSupport.AxisTickFormatParams;
+    datumFormatParams(value: Date | number, params: _ModuleSupport.FormatDatumParams, _fractionDigits: number | undefined, timeInterval: AgTimeInterval | AgTimeIntervalUnit | undefined, style: DateFormatterStyle): FormatterParams<any>;
+}

node_modules/ag-charts-enterprise/dist/types/src/axes/ordinal/ordinalTimeAxisModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgOrdinalTimeAxisOptions } from 'ag-charts-community';
+import type { AxisModuleDefinition } from 'ag-charts-core';
+export declare const OrdinalTimeAxisModule: AxisModuleDefinition<AgOrdinalTimeAxisOptions>;

node_modules/ag-charts-enterprise/dist/types/src/axes/polar-crosslines/angleCrossLine.d.ts

@@ -0,0 +1,19 @@
+import { ChartAxisDirection } from 'ag-charts-core';
+import { PolarCrossLine } from './polarCrossLine';
+export declare class AngleCrossLine extends PolarCrossLine {
+    static readonly className = "AngleCrossLine";
+    direction: ChartAxisDirection;
+    private readonly polygonNode;
+    private readonly sectorNode;
+    private readonly lineNode;
+    private readonly crossLineRange;
+    private readonly labelNode;
+    ticks: any[];
+    constructor();
+    visibilityCheck(): boolean;
+    update(visible: boolean): void;
+    private updateLineNode;
+    private updatePolygonNode;
+    private updateSectorNode;
+    private updateLabelNode;
+}

node_modules/ag-charts-enterprise/dist/types/src/axes/polar-crosslines/polarCrossLine.d.ts

@@ -0,0 +1,45 @@
+import type { AgBaseCrossLineLabelOptions } from 'ag-charts-community';
+import { _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties, ChartAxisDirection, type Scale } from 'ag-charts-core';
+declare const LabelStyle: typeof _ModuleSupport.LabelStyle;
+export declare class PolarCrossLineLabel extends LabelStyle implements AgBaseCrossLineLabelOptions {
+    enabled?: boolean;
+    padding: number;
+    text?: string;
+    parallel?: boolean;
+}
+export declare abstract class PolarCrossLine extends BaseProperties implements _ModuleSupport.PolarCrossLine {
+    static readonly className: string;
+    readonly id: string;
+    enabled?: boolean;
+    type: _ModuleSupport.CrossLineType;
+    range?: [unknown, unknown];
+    value?: unknown;
+    defaultColorRange: string[];
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    lineDash?: [];
+    shape: 'polygon' | 'circle';
+    label: PolarCrossLineLabel;
+    scale?: Scale<any, number>;
+    clippedRange: [number, number];
+    gridLength: number;
+    sideFlag: 1 | -1;
+    parallelFlipRotation: number;
+    regularFlipRotation: number;
+    direction: ChartAxisDirection;
+    axisInnerRadius: number;
+    axisOuterRadius: number;
+    readonly lineGroup: _ModuleSupport.Group<unknown>;
+    readonly rangeGroup: _ModuleSupport.Group<unknown>;
+    readonly labelGroup: _ModuleSupport.Group<unknown>;
+    private _isRange;
+    protected assignCrossLineGroup(isRange: boolean, crossLineRange: _ModuleSupport.Node): void;
+    abstract update(visible: boolean): void;
+    protected setSectorNodeProps(node: _ModuleSupport.Path | _ModuleSupport.Sector): void;
+    protected setLabelNodeProps(node: _ModuleSupport.RotatableText, x: number, y: number, baseline: CanvasTextBaseline, rotation: number): void;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/axes/polar-crosslines/radiusCrossLine.d.ts

@@ -0,0 +1,26 @@
+import { ChartAxisDirection } from 'ag-charts-core';
+import { PolarCrossLine, PolarCrossLineLabel } from './polarCrossLine';
+declare class RadiusCrossLineLabel extends PolarCrossLineLabel {
+    positionAngle?: number;
+}
+export declare class RadiusCrossLine extends PolarCrossLine {
+    static readonly className = "RadiusCrossLine";
+    direction: ChartAxisDirection;
+    gridAngles?: number[];
+    label: RadiusCrossLineLabel;
+    private readonly polygonNode;
+    private readonly sectorNode;
+    private readonly crossLineRange;
+    private readonly labelNode;
+    private outerRadius;
+    private innerRadius;
+    constructor();
+    update(visible: boolean): void;
+    private updateRadii;
+    private drawPolygon;
+    private updatePolygonNode;
+    private updateSectorNode;
+    private updateLabelNode;
+    private getPadding;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/axes/radius-category/radiusCategoryAxis.d.ts

@@ -0,0 +1,21 @@
+import { type FormatterParams, _ModuleSupport } from 'ag-charts-community';
+import type { DomainWithMetadata } from 'ag-charts-core';
+import { RadiusAxis } from '../radius/radiusAxis';
+export declare class RadiusCategoryAxis extends RadiusAxis {
+    static readonly className = "RadiusCategoryAxis";
+    static readonly type: "radius-category";
+    shape: "circle";
+    groupPaddingInner: number;
+    paddingInner: number;
+    paddingOuter: number;
+    constructor(moduleCtx: _ModuleSupport.ModuleContext);
+    hasDefinedDomain(): boolean;
+    normaliseDataDomain(d: DomainWithMetadata<string | object>): {
+        domain: (string | object)[];
+        clipped: boolean;
+    };
+    protected prepareGridPathTickData(data: _ModuleSupport.TickDatum[]): _ModuleSupport.TickDatum[];
+    protected getTickRadius(tickDatum: _ModuleSupport.TickDatum): number;
+    tickFormatParams(): _ModuleSupport.AxisTickFormatParams;
+    datumFormatParams(value: any, params: _ModuleSupport.FormatDatumParams): FormatterParams<any>;
+}

node_modules/ag-charts-enterprise/dist/types/src/axes/radius-category/radiusCategoryAxisModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgRadiusCategoryAxisOptions } from 'ag-charts-community';
+import type { AxisModuleDefinition } from 'ag-charts-core';
+export declare const RadiusCategoryAxisModule: AxisModuleDefinition<AgRadiusCategoryAxisOptions>;

node_modules/ag-charts-enterprise/dist/types/src/axes/radius-number/radiusNumberAxis.d.ts

@@ -0,0 +1,30 @@
+import { type FormatterParams, type TextOrSegments, _ModuleSupport } from 'ag-charts-community';
+import type { DomainWithMetadata } from 'ag-charts-core';
+import { RadiusAxis } from '../radius/radiusAxis';
+interface TickDatum {
+    tick: any;
+    tickId: string;
+    tickLabel: TextOrSegments | undefined;
+    translation: number;
+}
+export declare class RadiusNumberAxis extends RadiusAxis {
+    static readonly className = "RadiusNumberAxis";
+    static readonly type: "radius-number";
+    shape: 'polygon' | 'circle';
+    min?: number;
+    max?: number;
+    preferredMin?: number;
+    preferredMax?: number;
+    constructor(moduleCtx: _ModuleSupport.ModuleContext);
+    hasDefinedDomain(): boolean;
+    protected prepareGridPathTickData(data: _ModuleSupport.TickDatum[]): _ModuleSupport.TickDatum[];
+    protected getTickRadius(tickDatum: TickDatum): number;
+    normaliseDataDomain(d: DomainWithMetadata<number>): {
+        domain: number[];
+        clipped: boolean;
+    };
+    getDomainExtentsNice(): [boolean, boolean];
+    tickFormatParams(_domain: number[], _ticks: number[], fractionDigits?: number): _ModuleSupport.AxisTickFormatParams;
+    datumFormatParams(value: any, params: _ModuleSupport.FormatDatumParams, fractionDigits?: number): FormatterParams<any>;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/axes/radius-number/radiusNumberAxisModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgRadiusNumberAxisOptions } from 'ag-charts-community';
+import type { AxisModuleDefinition } from 'ag-charts-core';
+export declare const RadiusNumberAxisModule: AxisModuleDefinition<AgRadiusNumberAxisOptions>;

node_modules/ag-charts-enterprise/dist/types/src/axes/radius/radiusAxis.d.ts

@@ -0,0 +1,45 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { ChartAxisDirection, type Scale } from 'ag-charts-core';
+declare class RadiusAxisLabel extends _ModuleSupport.AxisLabel {
+    autoRotate?: boolean;
+    autoRotateAngle: number;
+}
+export declare abstract class RadiusAxis<S extends Scale<D, number, _ModuleSupport.TickInterval<S>> = Scale<any, number, any>, D = any> extends _ModuleSupport.PolarAxis<S, D> {
+    protected static CrossLineConstructor: new () => _ModuleSupport.CrossLine<any>;
+    positionAngle: number;
+    protected gridLineGroupSelection: _ModuleSupport.Selection<_ModuleSupport.Line, _ModuleSupport.TickDatum>;
+    private generatedTicks;
+    protected readonly headingLabelGroup: _ModuleSupport.TransformableGroup;
+    protected readonly lineNodeGroup: _ModuleSupport.TransformableGroup;
+    protected readonly lineNode: _ModuleSupport.Line;
+    protected readonly gridPathGroup: _ModuleSupport.Group<unknown>;
+    protected gridPathSelection: _ModuleSupport.Selection<_ModuleSupport.Path<unknown>, any>;
+    get direction(): ChartAxisDirection;
+    constructor(moduleCtx: _ModuleSupport.ModuleContext, scale: S);
+    private getAxisTransform;
+    update(): void;
+    updatePosition(): void;
+    calculateRotations(): {
+        rotation: number;
+        parallelFlipRotation: number;
+        regularFlipRotation: number;
+    };
+    calculateTickLayout(domain: D[], niceMode: [_ModuleSupport.NiceMode, _ModuleSupport.NiceMode], _visibleRange: [number, number]): {
+        niceDomain: D[];
+        tickDomain: D[];
+        ticks: D[];
+        rawTickCount: number | undefined;
+        fractionDigits: number;
+        timeInterval: undefined;
+    };
+    protected abstract prepareGridPathTickData(tickData: _ModuleSupport.TickDatum[]): _ModuleSupport.TickDatum[];
+    protected abstract getTickRadius(tickDatum: _ModuleSupport.TickDatum): number;
+    protected updateSelections(): void;
+    protected updateLabels(): void;
+    private updateGridLines;
+    private updateTitle;
+    protected updateCrossLines(): void;
+    protected createLabel(): RadiusAxisLabel;
+    private getTickLabelProps;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/charts/standaloneChart.d.ts

@@ -0,0 +1,10 @@
+import { _ModuleSupport } from 'ag-charts-community';
+declare const Chart: typeof _ModuleSupport.Chart;
+export declare class StandaloneChart extends Chart {
+    static readonly className = "StandaloneChart";
+    static readonly type: "standalone";
+    getChartType(): "standalone";
+    protected performLayout(ctx: _ModuleSupport.LayoutContext): void;
+    protected getAriaLabel(): string;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/charts/standaloneChartModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgStandaloneChartOptions } from 'ag-charts-community';
+import type { ChartModuleDefinition } from 'ag-charts-core';
+export declare const StandaloneChartModule: ChartModuleDefinition<AgStandaloneChartOptions>;

node_modules/ag-charts-enterprise/dist/types/src/charts/topologyChart.d.ts

@@ -0,0 +1,15 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import type { FeatureCollection } from 'ag-charts-core';
+declare const Chart: typeof _ModuleSupport.Chart;
+export declare class TopologyChart extends Chart {
+    static readonly className = "TopologyChart";
+    static readonly type: "topology";
+    private readonly xAxis;
+    private readonly yAxis;
+    topology?: FeatureCollection;
+    constructor(options: _ModuleSupport.ChartOptions, resources?: _ModuleSupport.TransferableResources);
+    getChartType(): "topology";
+    updateData(): void;
+    protected performLayout(ctx: _ModuleSupport.LayoutContext): void;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/charts/topologyChartModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgTopologyChartOptions } from 'ag-charts-community';
+import type { ChartModuleDefinition } from 'ag-charts-core';
+export declare const TopologyChartModule: ChartModuleDefinition<AgTopologyChartOptions>;

node_modules/ag-charts-enterprise/dist/types/src/components/color-picker/colorPicker.d.ts

@@ -0,0 +1,18 @@
+import { _ModuleSupport } from 'ag-charts-community';
+export interface ColorPickerOptions extends _ModuleSupport.AnchoredPopoverOptions {
+    color?: string;
+    opacity?: number;
+    isMultiColor?: boolean;
+    hasMultiColorOption: boolean;
+    sourceEvent: Event;
+    onChange?: (colorOpacity: string, color: string, opacity: number, isMultiColor: boolean) => void;
+    onChangeHide?: () => void;
+}
+export declare class ColorPicker extends _ModuleSupport.AnchoredPopover<ColorPickerOptions> {
+    private hasChanged;
+    private onChangeHide?;
+    private i18nUpdater?;
+    constructor(ctx: _ModuleSupport.ModuleContext, options?: _ModuleSupport.PopoverConstructorOptions);
+    show(options: ColorPickerOptions): void;
+    private createColorPicker;
+}

node_modules/ag-charts-enterprise/dist/types/src/components/dialog/dialog.d.ts

@@ -0,0 +1,103 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import type { CheckboxOptions as CoreCheckboxOptions, SelectOptions as CoreSelectOptions, TextAreaOptions as CoreTextAreaOptions } from 'ag-charts-core';
+import { type ElementID, type Point } from 'ag-charts-core';
+import type { AgIconName } from 'ag-charts-types';
+declare const DraggablePopover: typeof _ModuleSupport.DraggablePopover;
+export interface DialogOptions extends _ModuleSupport.PopoverOptions {
+}
+interface RadioGroupOptions<T extends string> {
+    label: string;
+    options: Array<{
+        icon: AgIconName;
+        altText: string;
+        value: T;
+    }>;
+    value: T;
+    onChange: (value: T) => void;
+}
+interface SelectOptions extends CoreSelectOptions {
+    altText: string;
+    label: string;
+}
+interface TextAreaOptions extends CoreTextAreaOptions {
+    placeholder: string;
+}
+interface CheckboxOptions extends CoreCheckboxOptions {
+    label: string;
+}
+interface ColorPickerOptions {
+    altText: string;
+    label: string;
+    color?: string;
+    opacity?: number;
+    isMultiColor?: boolean;
+    hasMultiColorOption: boolean;
+    onChange: (colorOpacity: string, color: string, opacity: number, isMultiColor: boolean) => void;
+    onChangeHide: () => void;
+}
+/**
+ * A popover that opens at a given position but can be moved by the user. By default, it opens at the bottom right or
+ * bottom middle of the chart on charts thinner or wider than 1000px respectively. It will reposition to be
+ * constrained within the boundaries of the chart.
+ *
+ * Dialogs may also contain tabs, inputs and nested color pickers.
+ */
+export declare abstract class Dialog<Options extends DialogOptions = DialogOptions> extends DraggablePopover<Options> {
+    private static readonly offset;
+    dragHandleDraggingClass: string;
+    private readonly colorPicker;
+    private colorPickerAnchorElement?;
+    private seriesRect?;
+    constructor(ctx: _ModuleSupport.ModuleContext, id: string);
+    protected showWithChildren(children: Array<HTMLElement>, options: Options): HTMLElement;
+    protected updatePosition(position: Point): void;
+    /**************
+     * Containers *
+     **************/
+    protected createTabs<T extends Record<string, {
+        label: string;
+        panel: HTMLElement;
+        onShow?: () => void;
+    }>>(tablistLabel: string, initial: keyof T, tabs: T): {
+        tabs: HTMLDivElement & HTMLElement & {
+            id: ElementID;
+        };
+        initialFocus: Record<keyof T, HTMLButtonElement & HTMLElement & {
+            id: ElementID;
+        }>[keyof T];
+    };
+    protected createTabPanel(): HTMLDivElement & HTMLElement & {
+        id: ElementID;
+    };
+    /**********
+     * Inputs *
+     **********/
+    protected createInputGroupLine(): HTMLDivElement & HTMLElement & {
+        id: ElementID;
+    };
+    protected createRadioGroup<T extends string>({ label, options, value, onChange }: RadioGroupOptions<T>): HTMLDivElement & HTMLElement & {
+        id: ElementID;
+    };
+    protected createSelect({ altText, label, options, value, onChange }: SelectOptions): HTMLDivElement & HTMLElement & {
+        id: ElementID;
+    };
+    protected createTextArea({ placeholder, value, onChange }: TextAreaOptions): HTMLTextAreaElement & HTMLElement & {
+        id: ElementID;
+    };
+    protected createCheckbox({ label, checked, onChange }: CheckboxOptions): HTMLDivElement & HTMLElement & {
+        id: ElementID;
+    };
+    protected createColorPicker({ color, opacity, label, altText, onChange, onChangeHide, isMultiColor, hasMultiColorOption, }: ColorPickerOptions): HTMLDivElement & HTMLElement & {
+        id: ElementID;
+    };
+    /***********
+     * Private *
+     ***********/
+    private createHeaderCloseButton;
+    private createInputGroup;
+    private onLayoutComplete;
+    private onKeyDown;
+    private reposition;
+    private getColorPickerAnchors;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/animation/animation.d.ts

@@ -0,0 +1,9 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { AbstractModuleInstance } from 'ag-charts-core';
+export declare class Animation extends AbstractModuleInstance {
+    protected readonly ctx: _ModuleSupport.ModuleContext;
+    enabled: boolean;
+    duration?: number;
+    maxAnimatableItems?: number;
+    constructor(ctx: _ModuleSupport.ModuleContext);
+}

node_modules/ag-charts-enterprise/dist/types/src/features/animation/animationModule.d.ts

@@ -0,0 +1,3 @@
+import { type PluginModuleDefinition } from 'ag-charts-core';
+import type { AgAnimationOptions } from 'ag-charts-types';
+export declare const AnimationModule: PluginModuleDefinition<AgAnimationOptions>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationAxesButtons.d.ts

@@ -0,0 +1,5 @@
+import { BaseProperties } from 'ag-charts-core';
+export declare class AxesButtons extends BaseProperties {
+    enabled: boolean;
+    axes?: 'x' | 'y' | 'xy';
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationDefaults.d.ts

@@ -0,0 +1,46 @@
+import { type AgAnnotationLineStyleType } from 'ag-charts-community';
+import type { MementoOriginator } from 'ag-charts-core';
+import { type AnnotationLineStyle, type AnnotationOptionsColorPickerType, AnnotationType, type ChannelTextPosition, type FibonacciAnnotationToolbarOptionsType, type FibonacciAnnotationType, type HasColorAnnotationType, type HasFontSizeAnnotationType, type HasLineStyleAnnotationType, type HasLineTextAnnotationType, type LineTextAlignment, type LineTextPosition } from './annotationTypes';
+import type { AnnotationProperties } from './annotationsSuperTypes';
+interface DefaultsMemento {
+    colors: DefaultColors;
+    fontSizes: DefaultFontSizes;
+    lineStyles: DefaultLineStyles;
+    lineTextAlignments: DefaultLineTextAlignments;
+    lineTextPositions: DefaultLineTextPositions;
+    fibonacciOptions: DefaultFibonacciOptions;
+}
+type DefaultColors = Map<AnnotationType, Map<AnnotationOptionsColorPickerType, [string, string, number, boolean] | undefined>>;
+type DefaultFontSizes = Map<HasFontSizeAnnotationType, number | undefined>;
+type DefaultLineStyles = Map<HasLineStyleAnnotationType, AnnotationLineStyle | undefined>;
+type DefaultLineTextAlignments = Map<HasLineTextAnnotationType, LineTextAlignment | undefined>;
+type DefaultLineTextPositions = Map<HasLineTextAnnotationType, LineTextPosition | ChannelTextPosition | undefined>;
+type DefaultFibonacciOptions = Map<FibonacciAnnotationType, FibonacciAnnotationToolbarOptionsType>;
+export declare class AnnotationDefaults implements MementoOriginator<DefaultsMemento> {
+    mementoOriginatorKey: "annotation-defaults";
+    private colors;
+    private fontSizes;
+    private lineStyles;
+    private lineTextAlignments;
+    private lineTextPositions;
+    private fibonacciOptions;
+    createMemento(): {
+        colors: DefaultColors;
+        fontSizes: DefaultFontSizes;
+        lineStyles: DefaultLineStyles;
+        lineTextAlignments: DefaultLineTextAlignments;
+        lineTextPositions: DefaultLineTextPositions;
+        fibonacciOptions: DefaultFibonacciOptions;
+    };
+    guardMemento(_blob: unknown): _blob is DefaultsMemento;
+    restoreMemento(_version: string, _mementoVersion: string, blob: DefaultsMemento): void;
+    setDefaultColor(type: HasColorAnnotationType, colorType: AnnotationOptionsColorPickerType, colorOpacity: string, color: string, opacity: number, isMultiColor: boolean): void;
+    setDefaultFontSize(type: HasFontSizeAnnotationType, fontSize: number): void;
+    setDefaultLineStyleType(type: HasLineStyleAnnotationType, lineStyleType: AgAnnotationLineStyleType | undefined): void;
+    setDefaultLineStyleWidth(type: HasLineStyleAnnotationType, strokeWidth: number): void;
+    setDefaultLineTextAlignment(type: HasLineTextAnnotationType, alignment: LineTextAlignment): void;
+    setDefaultLineTextPosition(type: HasLineTextAnnotationType, position: LineTextPosition | ChannelTextPosition): void;
+    setDefaultFibonacciOptions<K extends keyof FibonacciAnnotationToolbarOptionsType>(type: FibonacciAnnotationType | HasLineStyleAnnotationType, key: K, value: FibonacciAnnotationToolbarOptionsType[K]): void;
+    applyDefaults(datum: AnnotationProperties): void;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationOptionsToolbar.d.ts

@@ -0,0 +1,88 @@
+import { type AgAnnotationLineStyleType, _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties, EventEmitter, PropertiesArray } from 'ag-charts-core';
+import { ToolbarButtonProperties } from '../toolbar/buttonProperties';
+import { type AnnotationOptionsColorPickerType, type HasColorAnnotationType, type HasFontSizeAnnotationType, type HasLineStyleAnnotationType } from './annotationTypes';
+import { AnnotationOptions } from './annotationsMenuOptions';
+import type { AnnotationProperties, AnnotationScene } from './annotationsSuperTypes';
+interface EventMap {
+    'pressed-delete': null;
+    'pressed-settings': {
+        sourceEvent: Event;
+    };
+    'pressed-lock': {
+        locked: boolean;
+    };
+    'hid-overlays': null;
+    'saved-color': {
+        type: HasColorAnnotationType;
+        colorPickerType: AnnotationOptionsColorPickerType;
+        color: string | undefined;
+    };
+    'updated-color': {
+        type: HasColorAnnotationType;
+        colorPickerType: AnnotationOptionsColorPickerType;
+        colorOpacity: string;
+        color: string;
+        opacity: number;
+        isMultiColor: boolean;
+    };
+    'updated-font-size': {
+        type: HasFontSizeAnnotationType;
+        fontSize: number;
+    };
+    'updated-line-style': {
+        type: HasLineStyleAnnotationType;
+        lineStyleType: AgAnnotationLineStyleType;
+    };
+    'updated-line-width': {
+        type: HasLineStyleAnnotationType;
+        strokeWidth: number;
+    };
+}
+declare class AnnotationOptionsButtonProperties extends ToolbarButtonProperties {
+    value: AnnotationOptions;
+    checkedOverrides: ToolbarButtonProperties;
+    color?: string;
+    strokeWidth?: number;
+    isMultiColor?: boolean;
+}
+export declare class AnnotationOptionsToolbar extends BaseProperties {
+    private readonly ctx;
+    private readonly getActiveDatum;
+    enabled?: boolean;
+    buttons: PropertiesArray<AnnotationOptionsButtonProperties>;
+    private readonly cleanup;
+    readonly events: EventEmitter<EventMap>;
+    private visibleButtons;
+    private readonly toolbar;
+    private readonly colorPicker;
+    private readonly textSizeMenu;
+    private readonly lineStyleTypeMenu;
+    private readonly lineStrokeWidthMenu;
+    constructor(ctx: _ModuleSupport.ModuleContext, getActiveDatum: () => AnnotationProperties | undefined);
+    private onDragStart;
+    private onDragEnd;
+    destroy(): void;
+    show(): void;
+    hide(): void;
+    updateButtons(datum: AnnotationProperties): void;
+    setAnchorScene(scene: AnnotationScene): void;
+    hideOverlays(): void;
+    clearActiveButton(): void;
+    private updateColors;
+    updateColorPickerColor(colorPickerType: AnnotationOptionsColorPickerType, color?: string, opacity?: number, isMultiColor?: boolean): void;
+    private updateFontSize;
+    updateLineStyleType(item: _ModuleSupport.MenuItem<AgAnnotationLineStyleType>): void;
+    updateStrokeWidth(item: _ModuleSupport.MenuItem<number>): void;
+    private onButtonPress;
+    private onToolbarMoved;
+    private onColorPickerChange;
+    private onTextSizeMenuPress;
+    private onLineStyleTypeMenuPress;
+    private onLineStrokeWidthMenuPress;
+    private refreshButtons;
+    private updateLineStyles;
+    private updateButtonByValue;
+    private updateButtonByIndex;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationProperties.d.ts

@@ -0,0 +1,248 @@
+import type { AgAnnotationLineStyleType, FontStyle, FontWeight, Formatter, TextAlign } from 'ag-charts-community';
+import { _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties } from 'ag-charts-core';
+import type { AnnotationOptionsColorPickerType, ChannelTextPosition, Constructor, LineTextAlignment, LineTextPosition } from './annotationTypes';
+import type { PointType } from './utils/scale';
+/**************
+ * Components *
+ **************/
+export declare class PointProperties extends BaseProperties {
+    x?: PointType;
+    y?: PointType;
+}
+declare const ChannelAnnotationMiddleProperties_base: {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: AgAnnotationLineStyleType | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        visible?: boolean | undefined;
+    };
+} & typeof BaseProperties;
+export declare class ChannelAnnotationMiddleProperties extends ChannelAnnotationMiddleProperties_base {
+}
+declare const AxisLabelProperties_base: {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: AgAnnotationLineStyleType | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        padding?: number | undefined;
+        textAlign: TextAlign;
+        formatter?: Formatter<AxisLabelFormatterParams> | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        fontStyle?: FontStyle | undefined;
+        fontWeight?: FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & typeof BaseProperties;
+export declare class AxisLabelProperties extends AxisLabelProperties_base {
+    enabled?: boolean;
+    cornerRadius: number;
+}
+declare const BackgroundProperties_base: {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & typeof BaseProperties;
+declare class BackgroundProperties extends BackgroundProperties_base {
+}
+declare const HandleProperties_base: {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: AgAnnotationLineStyleType | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & typeof BaseProperties;
+declare class HandleProperties extends HandleProperties_base {
+}
+declare const LineTextProperties_base: {
+    new (...args: any[]): {
+        fontStyle?: FontStyle | undefined;
+        fontWeight?: FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & typeof BaseProperties;
+export declare class LineTextProperties extends LineTextProperties_base {
+    label: string;
+    position?: LineTextPosition;
+    alignment?: LineTextAlignment;
+}
+declare const LabelTextProperties_base: {
+    new (...args: any[]): {
+        fontStyle?: FontStyle | undefined;
+        fontWeight?: FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & typeof BaseProperties;
+export declare class LabelTextProperties extends LabelTextProperties_base {
+}
+declare const ChannelTextProperties_base: {
+    new (...args: any[]): {
+        fontStyle?: FontStyle | undefined;
+        fontWeight?: FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & typeof BaseProperties;
+export declare class ChannelTextProperties extends ChannelTextProperties_base {
+    label: string;
+    position?: ChannelTextPosition;
+    alignment?: LineTextAlignment;
+}
+export interface AxisLabelFormatterParams {
+    readonly value: any;
+}
+/*******************************
+ * Annotations specific mixins *
+ *******************************/
+export declare function Annotation<U extends Constructor<BaseProperties>>(Parent: U): (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType, isMultiColor?: boolean): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & U;
+export declare function Line<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        start: PointProperties;
+        end: PointProperties;
+    };
+} & T;
+export declare function Point<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        x?: PointType;
+        y?: PointType;
+    };
+} & T;
+export declare function Value<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        value?: PointType;
+    };
+} & T;
+export declare function Background<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        background: BackgroundProperties;
+    };
+} & T;
+export declare function Handle<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        handle: HandleProperties;
+    };
+} & T;
+export declare function AxisLabel<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        axisLabel: AxisLabelProperties;
+    };
+} & T;
+export declare function Label<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        padding?: number | undefined;
+        textAlign: TextAlign;
+        formatter?: Formatter<AxisLabelFormatterParams> | undefined;
+    };
+} & T;
+export declare function Cappable<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        startCap?: "arrow" | undefined;
+        endCap?: "arrow" | undefined;
+    };
+} & T;
+export declare function Extendable<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        extendStart?: boolean | undefined;
+        extendEnd?: boolean | undefined;
+    };
+} & T;
+export declare function Localisable<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        localeManager?: import("packages/ag-charts-community/dist/types/src/locale/localeManager").LocaleManager | undefined;
+        setLocaleManager(localeManager: _ModuleSupport.ModuleContext['localeManager']): void;
+    };
+} & T;
+export declare function Fill<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & T;
+export declare function Stroke<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & T;
+export declare function LineStyle<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: AgAnnotationLineStyleType | undefined;
+    };
+} & T;
+export declare function Font<T extends Constructor>(Parent: T): {
+    new (...args: any[]): {
+        fontStyle?: FontStyle | undefined;
+        fontWeight?: FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & T;
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationTypes.d.ts

@@ -0,0 +1,69 @@
+import type { AgAnnotationLineStyleType, _ModuleSupport } from 'ag-charts-community';
+import type { PointType } from './utils/scale';
+export type Constructor<T = object> = new (...args: any[]) => T;
+export declare enum AnnotationType {
+    Line = "line",
+    HorizontalLine = "horizontal-line",
+    VerticalLine = "vertical-line",
+    DisjointChannel = "disjoint-channel",
+    ParallelChannel = "parallel-channel",
+    FibonacciRetracement = "fibonacci-retracement",
+    FibonacciRetracementTrendBased = "fibonacci-retracement-trend-based",
+    Callout = "callout",
+    Comment = "comment",
+    Note = "note",
+    Text = "text",
+    Arrow = "arrow",
+    ArrowUp = "arrow-up",
+    ArrowDown = "arrow-down",
+    DateRange = "date-range",
+    PriceRange = "price-range",
+    DatePriceRange = "date-price-range",
+    QuickDatePriceRange = "quick-date-price-range"
+}
+type TextualAnnotationType = AnnotationType.Callout | AnnotationType.Comment | AnnotationType.Note | AnnotationType.Text;
+type LineAnnotationType = AnnotationType.Line | AnnotationType.HorizontalLine | AnnotationType.VerticalLine | AnnotationType.Arrow;
+type ChannelAnnotationType = AnnotationType.DisjointChannel | AnnotationType.ParallelChannel;
+type MeasurerAnnotationType = AnnotationType.DateRange | AnnotationType.PriceRange | AnnotationType.DatePriceRange | AnnotationType.QuickDatePriceRange;
+type EphemeralAnnotationType = AnnotationType.QuickDatePriceRange;
+export type FibonacciAnnotationType = AnnotationType.FibonacciRetracement | AnnotationType.FibonacciRetracementTrendBased;
+export type HasColorAnnotationType = AnnotationType;
+export type HasLineStyleAnnotationType = Exclude<LineAnnotationType | ChannelAnnotationType | MeasurerAnnotationType, EphemeralAnnotationType>;
+export type HasLineTextAnnotationType = Exclude<LineAnnotationType | ChannelAnnotationType | MeasurerAnnotationType, EphemeralAnnotationType>;
+export type HasFontSizeAnnotationType = Exclude<Exclude<TextualAnnotationType, AnnotationType.Note> | LineAnnotationType | ChannelAnnotationType | MeasurerAnnotationType, EphemeralAnnotationType>;
+export declare function stringToAnnotationType(value: unknown): AnnotationType | undefined;
+export interface DataPoint {
+    x?: PointType;
+    y?: PointType;
+}
+export interface Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export type FibonacciBands = 10 | 6 | 4;
+export interface AnnotationAxisContext extends Pick<_ModuleSupport.AxisContext, 'continuous' | 'direction' | 'position' | 'scale' | 'scaleInvert' | 'scaleInvertNearest' | 'formatScaleValue' | 'attachLabel' | 'inRange' | 'getRangeOverflow'> {
+    bounds: _ModuleSupport.BBox;
+    labelPadding: number;
+    snapToGroup: boolean;
+}
+export type AnnotationContext = {
+    seriesRect: _ModuleSupport.BBox;
+    xAxis: AnnotationAxisContext;
+    yAxis: AnnotationAxisContext;
+};
+export type AnnotationOptionsColorPickerType = 'line-color' | 'fill-color' | 'text-color';
+export type FibonacciAnnotationToolbarOptionsType = {
+    bands?: FibonacciBands;
+    reverse?: boolean;
+    showFill?: boolean;
+};
+export type AnnotationLineStyle = {
+    type?: AgAnnotationLineStyleType;
+    strokeWidth?: number;
+};
+export type LineTextAlignment = 'left' | 'center' | 'right';
+export type LineTextPosition = 'top' | 'center' | 'bottom';
+export type ChannelTextPosition = 'top' | 'inside' | 'bottom';
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotations.d.ts

@@ -0,0 +1,94 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { AbstractModuleInstance } from 'ag-charts-core';
+import { AxesButtons } from './annotationAxesButtons';
+import { AnnotationOptionsToolbar } from './annotationOptionsToolbar';
+import { AnnotationsToolbar } from './annotationsToolbar';
+export declare class Annotations extends AbstractModuleInstance {
+    private readonly ctx;
+    readonly toolbar: AnnotationsToolbar;
+    optionsToolbar: AnnotationOptionsToolbar;
+    axesButtons: AxesButtons;
+    enabled: boolean;
+    snap: boolean;
+    data?: any[];
+    xKey?: string;
+    volumeKey?: string;
+    private readonly state;
+    private readonly annotationData;
+    private readonly defaults;
+    private dataModel?;
+    private processedData?;
+    private seriesRect?;
+    private readonly container;
+    private readonly annotations;
+    private readonly settingsDialog;
+    private readonly textInput;
+    private xAxis?;
+    private yAxis?;
+    private postUpdateFns;
+    constructor(ctx: _ModuleSupport.ModuleContext);
+    private setupStateMachine;
+    private setupListeners;
+    private setupDOM;
+    processData(dataController: _ModuleSupport.DataController): Promise<void>;
+    /**
+     * Create an annotation scene within the `this.annotations` scene selection. This method is automatically called by
+     * the selection when a new scene is required.
+     */
+    private createAnnotationScene;
+    /**
+     * Create an annotation datum within the `this.annotationData` properties array. It is created as an instance
+     * of `AnnotationProperties` from the given config for its type. This method is only called when annotations
+     * are added from the initial state.
+     */
+    private static createAnnotationDatum;
+    /**
+     * Append an annotation datum to `this.annotationData`, applying default styles. This method is called when a user
+     * interacts with the chart to draw their own annotations.
+     */
+    private createAnnotation;
+    private injectDatumDependencies;
+    private getDatumRangeVolume;
+    private translateNode;
+    private createAnnotationDatumCopy;
+    private getAnnotationConfig;
+    private onRestoreAnnotations;
+    private onLayoutComplete;
+    private showAnnotations;
+    private animateAnnotations;
+    private onPreRender;
+    private getAxis;
+    private recordActionAfterNextUpdate;
+    private setColorAndDefault;
+    private setFontSizeAndDefault;
+    private setLineStyleTypeAndDefault;
+    private setLineStyleWidthAndDefault;
+    private updateAnnotations;
+    private getAnnotationContext;
+    private onHover;
+    private onClick;
+    private onDoubleClick;
+    private onAxisButtonClick;
+    private onResize;
+    private hoverTouchPreHandler;
+    private dragMoveTouchPreHandler;
+    private onDragStart;
+    private onDrag;
+    private onDragEnd;
+    private onCancel;
+    private onDelete;
+    private onTextInput;
+    private onKeyDown;
+    private onKeyUp;
+    private clear;
+    private reset;
+    private cancel;
+    private delete;
+    private deleteAll;
+    private deleteEphemeralAnnotations;
+    private hideOverlays;
+    private pushAnnotationState;
+    private popAnnotationState;
+    private isAnnotationState;
+    private update;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationsConfig.d.ts

@@ -0,0 +1,4 @@
+export declare const annotationConfigs: {
+    [x: string]: import("./annotationsSuperTypes").AnnotationTypeConfig<import("./arrow-down/arrowDownProperties").ArrowDownProperties, import("./arrow-down/arrowDownScene").ArrowDownScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./arrow-up/arrowUpProperties").ArrowUpProperties, import("./arrow-up/arrowUpScene").ArrowUpScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./callout/calloutProperties").CalloutProperties, import("./callout/calloutScene").CalloutScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./comment/commentProperties").CommentProperties, import("./comment/commentScene").CommentScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./cross-line/crossLineProperties").HorizontalLineProperties, import("./cross-line/crossLineScene").CrossLineScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./cross-line/crossLineProperties").VerticalLineProperties, import("./cross-line/crossLineScene").CrossLineScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./disjoint-channel/disjointChannelProperties").DisjointChannelProperties, import("./disjoint-channel/disjointChannelScene").DisjointChannelScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedProperties").FibonacciRetracementTrendBasedProperties, import("./fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedScene").FibonacciRetracementTrendBasedScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./fibonacci-retracement/fibonacciRetracementProperties").FibonacciRetracementProperties, import("./fibonacci-retracement/fibonacciRetracementScene").FibonacciRetracementScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./line/lineProperties").LineProperties, import("./line/lineScene").LineScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./line/lineProperties").ArrowProperties, import("./line/lineScene").LineScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./measurer/measurerProperties").DateRangeProperties, import("./measurer/measurerScene").MeasurerScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./measurer/measurerProperties").PriceRangeProperties, import("./measurer/measurerScene").MeasurerScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./measurer/measurerProperties").DatePriceRangeProperties, import("./measurer/measurerScene").MeasurerScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./measurer/measurerProperties").QuickDatePriceRangeProperties, import("./measurer/measurerScene").QuickMeasurerScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./note/noteProperties").NoteProperties, import("./note/noteScene").NoteScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./parallel-channel/parallelChannelProperties").ParallelChannelProperties, import("./parallel-channel/parallelChannelScene").ParallelChannelScene> | import("./annotationsSuperTypes").AnnotationTypeConfig<import("./text/textProperties").TextProperties, import("./text/textScene").TextScene>;
+};
+export declare function getTypedDatum(datum: unknown): import("./arrow-down/arrowDownProperties").ArrowDownProperties | import("./arrow-up/arrowUpProperties").ArrowUpProperties | import("./callout/calloutProperties").CalloutProperties | import("./comment/commentProperties").CommentProperties | import("./cross-line/crossLineProperties").HorizontalLineProperties | import("./cross-line/crossLineProperties").VerticalLineProperties | import("./disjoint-channel/disjointChannelProperties").DisjointChannelProperties | import("./line/lineProperties").ArrowProperties | import("./line/lineProperties").LineProperties | import("./fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedProperties").FibonacciRetracementTrendBasedProperties | import("./fibonacci-retracement/fibonacciRetracementProperties").FibonacciRetracementProperties | import("./measurer/measurerProperties").DateRangeProperties | import("./measurer/measurerProperties").PriceRangeProperties | import("./measurer/measurerProperties").DatePriceRangeProperties | import("./measurer/measurerProperties").QuickDatePriceRangeProperties | import("./note/noteProperties").NoteProperties | import("./parallel-channel/parallelChannelProperties").ParallelChannelProperties | import("./text/textProperties").TextProperties | undefined;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationsMenuOptions.d.ts

@@ -0,0 +1,25 @@
+import { type AgAnnotationLineStyleType, _ModuleSupport } from 'ag-charts-community';
+import type { Scale } from 'ag-charts-core';
+import { AnnotationType } from './annotationTypes';
+export declare enum AnnotationOptions {
+    Delete = "delete",
+    LineStrokeWidth = "line-stroke-width",
+    LineStyleType = "line-style-type",
+    LineColor = "line-color",
+    FillColor = "fill-color",
+    Lock = "lock",
+    TextColor = "text-color",
+    TextSize = "text-size",
+    Settings = "settings"
+}
+export declare const LINE_ANNOTATION_ITEMS: (_ModuleSupport.MenuItem<AnnotationType> & {
+    visible?: (axisScale: Scale<any, any>) => boolean;
+})[];
+export declare const FIBONACCI_ANNOTATION_ITEMS: _ModuleSupport.MenuItem<AnnotationType>[];
+export declare const FIBONACCI_RATIO_ITEMS: _ModuleSupport.MenuItem<number>[];
+export declare const TEXT_ANNOTATION_ITEMS: _ModuleSupport.MenuItem<AnnotationType>[];
+export declare const SHAPE_ANNOTATION_ITEMS: _ModuleSupport.MenuItem<AnnotationType>[];
+export declare const MEASURER_ANNOTATION_ITEMS: _ModuleSupport.MenuItem<AnnotationType>[];
+export declare const LINE_STROKE_WIDTH_ITEMS: _ModuleSupport.MenuItem<number>[];
+export declare const LINE_STYLE_TYPE_ITEMS: _ModuleSupport.MenuItem<AgAnnotationLineStyleType>[];
+export declare const TEXT_SIZE_ITEMS: _ModuleSupport.MenuItem<number>[];

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationsModule.d.ts

@@ -0,0 +1,3 @@
+import { type AgAnnotationsOptions } from 'ag-charts-community';
+import { type PluginModuleDefinition } from 'ag-charts-core';
+export declare const AnnotationsModule: PluginModuleDefinition<AgAnnotationsOptions>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationsStateMachine.d.ts

@@ -0,0 +1,28 @@
+import { ParallelStateMachine } from 'ag-charts-core';
+import type { AnnotationProperties, AnnotationScene, AnnotationsStateMachineContext } from './annotationsSuperTypes';
+import type { AnnotationStateEvents } from './states/stateTypes';
+declare enum States {
+    Idle = "idle",
+    Dragging = "dragging",
+    Translating = "translating",
+    TextInput = "text-input"
+}
+/**
+ * - AnnotationsStateMachine (runs children in parallel, distributes properties across children)
+ *     - SnappingStateMachine (changes `snapping` property with shift key)
+ *     - UpdateStateMachine (ensures the active `node` is set after renders)
+ *     - AnnotationsMainStateMachine
+ *         - Idle (most interactions, with child machine per annotation type for creating annotations)
+ *         - Dragging (entered on `dragStart`, dragging interactions with child machine per annotation type)
+ *         - TextInput (entered on `click` of active text node, text input interactions)
+ */
+export declare class AnnotationsStateMachine extends ParallelStateMachine<States, AnnotationStateEvents> {
+    private active?;
+    protected snapping: boolean;
+    protected datum?: AnnotationProperties;
+    protected node?: AnnotationScene;
+    constructor(ctx: AnnotationsStateMachineContext);
+    getActive(): number | undefined;
+    isActive(index: number): boolean;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationsSuperTypes.d.ts

@@ -0,0 +1,91 @@
+import type { _ModuleSupport } from 'ag-charts-community';
+import type { Point } from 'ag-charts-core';
+import { BaseProperties, type StateMachine } from 'ag-charts-core';
+import type { AnnotationContext, AnnotationType, Constructor, DataPoint } from './annotationTypes';
+import type { ArrowDownProperties } from './arrow-down/arrowDownProperties';
+import type { ArrowDownScene } from './arrow-down/arrowDownScene';
+import type { ArrowUpProperties } from './arrow-up/arrowUpProperties';
+import type { ArrowUpScene } from './arrow-up/arrowUpScene';
+import type { CalloutProperties } from './callout/calloutProperties';
+import type { CalloutScene } from './callout/calloutScene';
+import type { CommentProperties } from './comment/commentProperties';
+import type { CommentScene } from './comment/commentScene';
+import type { HorizontalLineProperties, VerticalLineProperties } from './cross-line/crossLineProperties';
+import type { CrossLineScene } from './cross-line/crossLineScene';
+import type { DisjointChannelProperties } from './disjoint-channel/disjointChannelProperties';
+import type { DisjointChannelScene } from './disjoint-channel/disjointChannelScene';
+import type { FibonacciRetracementTrendBasedProperties } from './fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedProperties';
+import type { FibonacciRetracementTrendBasedScene } from './fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedScene';
+import type { FibonacciRetracementProperties } from './fibonacci-retracement/fibonacciRetracementProperties';
+import type { FibonacciRetracementScene } from './fibonacci-retracement/fibonacciRetracementScene';
+import type { ArrowProperties, LineProperties } from './line/lineProperties';
+import type { LineScene } from './line/lineScene';
+import type { DatePriceRangeProperties, DateRangeProperties, PriceRangeProperties, QuickDatePriceRangeProperties } from './measurer/measurerProperties';
+import type { MeasurerScene } from './measurer/measurerScene';
+import type { NoteProperties } from './note/noteProperties';
+import type { NoteScene } from './note/noteScene';
+import type { ParallelChannelProperties } from './parallel-channel/parallelChannelProperties';
+import type { ParallelChannelScene } from './parallel-channel/parallelChannelScene';
+import type { AnnotationScene as AnnotationSceneNode } from './scenes/annotationScene';
+import type { TextProperties } from './text/textProperties';
+import type { TextScene } from './text/textScene';
+type ShapePropertiesType = ArrowUpProperties | ArrowDownProperties;
+export type TextualPropertiesType = CalloutProperties | CommentProperties | NoteProperties | TextProperties;
+export type LinePropertiesType = LineProperties | HorizontalLineProperties | VerticalLineProperties | ArrowProperties;
+export type FibonacciPropertiesType = FibonacciRetracementProperties | FibonacciRetracementTrendBasedProperties;
+export type ChannelPropertiesType = ParallelChannelProperties | DisjointChannelProperties;
+export type MeasurerPropertiesType = DateRangeProperties | PriceRangeProperties | DatePriceRangeProperties | QuickDatePriceRangeProperties;
+export type AnnotationProperties = LinePropertiesType | ChannelPropertiesType | FibonacciPropertiesType | TextualPropertiesType | ShapePropertiesType | MeasurerPropertiesType;
+export type EphemeralPropertiesType = QuickDatePriceRangeProperties;
+export type AnnotationScene = LineScene | CrossLineScene | ParallelChannelScene | DisjointChannelScene | FibonacciRetracementScene | FibonacciRetracementTrendBasedScene | ArrowUpScene | ArrowDownScene | CalloutScene | CommentScene | NoteScene | TextScene | MeasurerScene;
+export interface AnnotationsStateMachineContext {
+    resetToIdle: () => void;
+    hoverAtCoords: (coords: Point, active?: number, hovered?: number) => number | undefined;
+    getNodeAtCoords: (coords: Point, active: number) => string | undefined;
+    select: (index?: number, previous?: number) => void;
+    selectLast: () => number;
+    startInteracting: () => void;
+    stopInteracting: () => void;
+    translate: (index: number, translation: Point) => void;
+    copy: (index: number) => AnnotationProperties | undefined;
+    paste: (datum: AnnotationProperties) => void;
+    create: (type: AnnotationType, datum: AnnotationProperties) => void;
+    delete: (index: number) => void;
+    deleteAll: () => void;
+    validatePoint: (point: DataPoint, options?: {
+        overflowContinuous: boolean;
+    }) => boolean;
+    getAnnotationType: (index: number) => AnnotationType | undefined;
+    datum: (index: number) => AnnotationProperties | undefined;
+    node: (index: number) => AnnotationScene | undefined;
+    showTextInput: (index: number) => void;
+    hideTextInput: () => void;
+    updateTextInputColor: (color: string) => void;
+    updateTextInputFontSize: (fontSize: number) => void;
+    updateTextInputBBox: (bbox?: _ModuleSupport.BBox) => void;
+    showAnnotationOptions: (index: number) => void;
+    showAnnotationSettings: (index: number, sourceEvent?: Event, initialTab?: 'line' | 'text') => void;
+    recordAction: (label: string) => void;
+    update: () => void;
+}
+export interface AnnotationTypeConfig<Datum extends BaseProperties, Scene extends AnnotationSceneNode> {
+    type: AnnotationType;
+    isDatum: (value: unknown) => value is Datum;
+    datum: Constructor<Datum>;
+    scene: Constructor<Scene>;
+    update: (node: AnnotationSceneNode, datum: BaseProperties, context: AnnotationContext) => void;
+    translate: (node: AnnotationSceneNode, datum: BaseProperties, translation: Point, context: AnnotationContext) => void;
+    copy: (node: AnnotationSceneNode, datum: BaseProperties, copiedDatum: BaseProperties, context: AnnotationContext) => Datum | undefined;
+    createState: (ctx: AnnotationsCreateStateMachineContext, helpers: AnnotationsStateMachineHelperFns) => StateMachine<any, any>;
+    dragState: (ctx: AnnotationsStateMachineContext, helpers: AnnotationsStateMachineHelperFns) => StateMachine<any, any>;
+}
+export interface AnnotationsStateMachineHelperFns {
+    createDatum: <T extends AnnotationProperties>(type: AnnotationType) => (datum: T) => void;
+}
+export type AnnotationsCreateStateMachineContext = AnnotationsStateMachineContext & {
+    delete: () => void;
+    deselect: () => void;
+    showAnnotationOptions: () => void;
+    showTextInput: () => void;
+};
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationsTheme.d.ts

@@ -0,0 +1,2 @@
+import { type AgAnnotationsThemeableOptions, type WithThemeParams } from 'ag-charts-community';
+export declare const annotationsTheme: WithThemeParams<AgAnnotationsThemeableOptions>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/annotationsToolbar.d.ts

@@ -0,0 +1,44 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties, EventEmitter, PropertiesArray } from 'ag-charts-core';
+import { ToolbarButtonProperties } from '../toolbar/buttonProperties';
+import { type AnnotationType } from './annotationTypes';
+interface EventMap {
+    'cancel-create-annotation': null;
+    'pressed-create-annotation': {
+        annotation: AnnotationType;
+    };
+    'pressed-clear': null;
+    'pressed-show-menu': null;
+    'pressed-unrelated': null;
+}
+type AnnotationsToolbarButtonValue = 'line-menu' | 'fibonacci-menu' | 'text-menu' | 'shape-menu' | 'measurer-menu' | 'clear';
+declare class AnnotationsToolbarButtonProperties extends ToolbarButtonProperties {
+    value: AnnotationsToolbarButtonValue;
+}
+export declare class AnnotationsToolbar extends BaseProperties {
+    private readonly ctx;
+    enabled?: boolean;
+    /**
+     * The padding between the toolbar and the chart area.
+     */
+    padding: number;
+    buttons: PropertiesArray<AnnotationsToolbarButtonProperties>;
+    readonly events: EventEmitter<EventMap>;
+    private readonly toolbar;
+    private readonly annotationMenu;
+    private readonly cleanup;
+    constructor(ctx: _ModuleSupport.ModuleContext);
+    destroy(): void;
+    toggleClearButtonEnabled(enabled: boolean): void;
+    resetButtonIcons(): void;
+    hideOverlays(): void;
+    clearActiveButton(): void;
+    private onLayoutStart;
+    refreshButtonsEnabled(enabled: boolean): void;
+    private onToolbarButtonPress;
+    private onToolbarButtonPressShowMenu;
+    private onButtonPressMenuCreateAnnotation;
+    private onKeyDown;
+    private updateButtonByIndex;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-down/arrowDownConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { ArrowDownProperties } from './arrowDownProperties';
+import { ArrowDownScene } from './arrowDownScene';
+export declare const arrowDownConfig: AnnotationTypeConfig<ArrowDownProperties, ArrowDownScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-down/arrowDownProperties.d.ts

@@ -0,0 +1,6 @@
+import { AnnotationType } from '../annotationTypes';
+import { ShapePointProperties } from '../properties/shapePointProperties';
+export declare class ArrowDownProperties extends ShapePointProperties {
+    static is(this: void, value: unknown): value is ArrowDownProperties;
+    type: AnnotationType.ArrowDown;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-down/arrowDownScene.d.ts

@@ -0,0 +1,17 @@
+import type { Point } from 'ag-charts-core';
+import { type AnnotationContext, AnnotationType } from '../annotationTypes';
+import { AnnotationShape } from '../scenes/annotationShape';
+import { ShapePointScene } from '../scenes/shapePointScene';
+import type { ArrowDownProperties } from './arrowDownProperties';
+export declare class ArrowDownScene extends ShapePointScene<ArrowDownProperties> {
+    static is(value: unknown): value is ArrowDownScene;
+    type: AnnotationType;
+    protected readonly shape: AnnotationShape;
+    constructor();
+    updateAnchor(datum: ArrowDownProperties, point: Point, context: AnnotationContext): {
+        x: number;
+        y: number;
+        position: "right" | "above" | "above-left" | "below" | undefined;
+    };
+    protected getHandleCoords(datum: ArrowDownProperties, point: Point): Point;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-down/arrowDownState.d.ts

@@ -0,0 +1,6 @@
+import { PointStateMachine } from '../states/pointState';
+import { ArrowDownProperties } from './arrowDownProperties';
+import type { ArrowDownScene } from './arrowDownScene';
+export declare class ArrowDownStateMachine extends PointStateMachine<ArrowDownProperties, ArrowDownScene> {
+    protected createDatum(): ArrowDownProperties;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-up/arrowUpConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { ArrowUpProperties } from './arrowUpProperties';
+import { ArrowUpScene } from './arrowUpScene';
+export declare const arrowUpConfig: AnnotationTypeConfig<ArrowUpProperties, ArrowUpScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-up/arrowUpProperties.d.ts

@@ -0,0 +1,6 @@
+import { AnnotationType } from '../annotationTypes';
+import { ShapePointProperties } from '../properties/shapePointProperties';
+export declare class ArrowUpProperties extends ShapePointProperties {
+    static is(this: void, value: unknown): value is ArrowUpProperties;
+    type: AnnotationType.ArrowUp;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-up/arrowUpScene.d.ts

@@ -0,0 +1,13 @@
+import type { Point } from 'ag-charts-core';
+import { AnnotationType } from '../annotationTypes';
+import { AnnotationShape } from '../scenes/annotationShape';
+import { ShapePointScene } from '../scenes/shapePointScene';
+import type { ArrowUpProperties } from './arrowUpProperties';
+export declare const arrowUpPoints: Array<[number, number]>;
+export declare class ArrowUpScene extends ShapePointScene<ArrowUpProperties> {
+    static is(value: unknown): value is ArrowUpScene;
+    type: AnnotationType;
+    protected readonly shape: AnnotationShape;
+    constructor();
+    protected getHandleCoords(datum: ArrowUpProperties, point: Point): Point;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/arrow-up/arrowUpState.d.ts

@@ -0,0 +1,6 @@
+import { PointStateMachine } from '../states/pointState';
+import { ArrowUpProperties } from './arrowUpProperties';
+import type { ArrowUpScene } from './arrowUpScene';
+export declare class ArrowUpStateMachine extends PointStateMachine<ArrowUpProperties, ArrowUpScene> {
+    protected createDatum(): ArrowUpProperties;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/axisButton.d.ts

@@ -0,0 +1,32 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { AbstractModuleInstance, type Point } from 'ag-charts-core';
+export declare const DEFAULT_ANNOTATION_AXIS_BUTTON_CLASS = "ag-charts-annotations__axis-button";
+export declare class AxisButton extends AbstractModuleInstance {
+    private readonly ctx;
+    private readonly axisCtx;
+    private readonly onButtonClick;
+    private seriesRect;
+    enabled: boolean;
+    private readonly button;
+    private readonly snap;
+    private padding;
+    private coords?;
+    constructor(ctx: _ModuleSupport.ModuleContext, axisCtx: _ModuleSupport.AxisContext & {
+        snapToGroup: boolean;
+    }, onButtonClick: (coords?: Point) => void, seriesRect: _ModuleSupport.BBox);
+    update(seriesRect: _ModuleSupport.BBox, padding: number): void;
+    private setup;
+    private destroyElements;
+    private onMouseMove;
+    private onMouseDrag;
+    private onMouseLeave;
+    private onClick;
+    private show;
+    private hide;
+    private onKeyPress;
+    private getButtonCoordinates;
+    private toggleVisibility;
+    private toggleClass;
+    private updatePosition;
+    private updateButtonElement;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/callout/calloutConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { CalloutProperties } from './calloutProperties';
+import { CalloutScene } from './calloutScene';
+export declare const calloutConfig: AnnotationTypeConfig<CalloutProperties, CalloutScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/callout/calloutProperties.d.ts

@@ -0,0 +1,29 @@
+import { type AnnotationContext, type AnnotationOptionsColorPickerType, AnnotationType, type Padding } from '../annotationTypes';
+import { TextualStartEndProperties } from '../properties/textualStartEndProperties';
+declare const CalloutProperties_base: {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & typeof TextualStartEndProperties;
+export declare class CalloutProperties extends CalloutProperties_base {
+    static is(this: void, value: unknown): value is CalloutProperties;
+    type: AnnotationType.Callout;
+    position: "bottom";
+    alignment: "left";
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getPlaceholderColor(): string;
+    getPadding(): Padding;
+    getTextInputCoords(context: AnnotationContext, height: number): {
+        x: number;
+        y: number;
+    };
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/callout/calloutScene.d.ts

@@ -0,0 +1,45 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import type { Bounds4, BoxBounds, Point } from 'ag-charts-core';
+import { type AnnotationContext, AnnotationType } from '../annotationTypes';
+import { TextualStartEndScene } from '../scenes/textualStartEndScene';
+import type { CalloutProperties } from './calloutProperties';
+interface CalloutDimensions {
+    tailPoint: {
+        x: number;
+        y: number;
+    };
+    bodyBounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+type PathType = 'corner' | 'side' | 'calloutCorner' | 'calloutSide';
+export declare class CalloutScene extends TextualStartEndScene<CalloutProperties> {
+    static is(value: unknown): value is CalloutScene;
+    type: AnnotationType;
+    private readonly shape;
+    constructor();
+    drag(datum: CalloutProperties, target: Point, context: AnnotationContext, snapping: boolean): void;
+    protected getLabelCoords(datum: CalloutProperties, bbox: BoxBounds, coords: Bounds4): Point;
+    protected getHandleStyles(datum: CalloutProperties, handle: 'start' | 'end'): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    } | {
+        fill: undefined;
+        strokeWidth: number;
+        stroke?: undefined;
+        strokeOpacity?: undefined;
+    };
+    protected updateAnchor(datum: CalloutProperties, coords: Bounds4, context: AnnotationContext, bbox: _ModuleSupport.BBox): void;
+    protected updateShape(datum: CalloutProperties, textBox: BoxBounds, coords: Bounds4): void;
+    private updatePath;
+    drawPath(path: _ModuleSupport.ExtendedPath2D, { x0, y0, x1, y1, cx, cy }: _ModuleSupport.Corner, cornerRadius: number, type: PathType): void;
+    private calculateCalloutPlacement;
+    getDimensions(datum: CalloutProperties, textBox: BoxBounds, coords: Bounds4): CalloutDimensions | undefined;
+    containsPoint(x: number, y: number): boolean;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/callout/calloutState.d.ts

@@ -0,0 +1,6 @@
+import { TextualStartEndStateMachine } from '../states/textualStartEndState';
+import { CalloutProperties } from './calloutProperties';
+import type { CalloutScene } from './calloutScene';
+export declare class CalloutStateMachine extends TextualStartEndStateMachine<CalloutProperties, CalloutScene> {
+    protected createDatum(): CalloutProperties;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/comment/commentConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { CommentProperties } from './commentProperties';
+import { CommentScene } from './commentScene';
+export declare const commentConfig: AnnotationTypeConfig<CommentProperties, CommentScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/comment/commentProperties.d.ts

@@ -0,0 +1,29 @@
+import { type AnnotationContext, type AnnotationOptionsColorPickerType, AnnotationType, type Padding } from '../annotationTypes';
+import { TextualPointProperties } from '../properties/textualPointProperties';
+declare const CommentProperties_base: {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & typeof TextualPointProperties;
+export declare class CommentProperties extends CommentProperties_base {
+    static is(this: void, value: unknown): value is CommentProperties;
+    type: AnnotationType.Comment;
+    position: "bottom";
+    alignment: "left";
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getPlaceholderColor(): string;
+    getPadding(): Padding;
+    getTextInputCoords(context: AnnotationContext, height: number): {
+        x: number;
+        y: number;
+    };
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/comment/commentScene.d.ts

@@ -0,0 +1,26 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { type Point } from 'ag-charts-core';
+import { type AnnotationContext, AnnotationType } from '../annotationTypes';
+import { TextualPointScene } from '../scenes/textualPointScene';
+import type { CommentProperties } from './commentProperties';
+export declare class CommentScene extends TextualPointScene<CommentProperties> {
+    static is(value: unknown): value is CommentScene;
+    type: AnnotationType;
+    private readonly shape;
+    constructor();
+    protected updateShape(datum: CommentProperties, bbox: _ModuleSupport.BBox): void;
+    protected getLabelCoords(datum: CommentProperties, point: Point): Point;
+    protected getHandleStyles(datum: CommentProperties): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    };
+    protected updateAnchor(datum: CommentProperties, bbox: _ModuleSupport.BBox, context: AnnotationContext): {
+        x: number;
+        y: number;
+        position: "right" | "above" | "above-left" | "below" | undefined;
+    };
+    private updatePath;
+    containsPoint(x: number, y: number): boolean;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/comment/commentState.d.ts

@@ -0,0 +1,6 @@
+import { TextualPointStateMachine } from '../states/textualPointState';
+import { CommentProperties } from './commentProperties';
+import type { CommentScene } from './commentScene';
+export declare class CommentStateMachine extends TextualPointStateMachine<CommentProperties, CommentScene> {
+    protected createDatum(): CommentProperties;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/cross-line/crossLineConfig.d.ts

@@ -0,0 +1,5 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { HorizontalLineProperties, VerticalLineProperties } from './crossLineProperties';
+import { CrossLineScene } from './crossLineScene';
+export declare const horizontalLineConfig: AnnotationTypeConfig<HorizontalLineProperties, CrossLineScene>;
+export declare const verticalLineConfig: AnnotationTypeConfig<VerticalLineProperties, CrossLineScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/cross-line/crossLineProperties.d.ts

@@ -0,0 +1,134 @@
+import { type PixelSize, _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties } from 'ag-charts-core';
+import { LineTextProperties } from '../annotationProperties';
+import { AnnotationType } from '../annotationTypes';
+declare const HorizontalLineProperties_base: (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: import("../annotationTypes").AnnotationOptionsColorPickerType, isMultiColor?: boolean | undefined): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & {
+    new (...args: any[]): {
+        value?: import("../utils/scale").PointType;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        axisLabel: import("../annotationProperties").AxisLabelProperties;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+    };
+} & typeof BaseProperties;
+export declare class HorizontalLineProperties extends HorizontalLineProperties_base {
+    readonly direction = "horizontal";
+    static is(this: void, value: unknown): value is HorizontalLineProperties;
+    type: AnnotationType.HorizontalLine;
+    text: LineTextProperties;
+    getDefaultColor(): string | undefined;
+    getDefaultOpacity(): number | undefined;
+    getLineDash(): PixelSize[] | undefined;
+    getLineCap(): _ModuleSupport.ShapeLineCap | undefined;
+}
+declare const VerticalLineProperties_base: (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: import("../annotationTypes").AnnotationOptionsColorPickerType, isMultiColor?: boolean | undefined): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & {
+    new (...args: any[]): {
+        value?: import("../utils/scale").PointType;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        axisLabel: import("../annotationProperties").AxisLabelProperties;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+    };
+} & typeof BaseProperties;
+export declare class VerticalLineProperties extends VerticalLineProperties_base {
+    readonly direction = "vertical";
+    static is(this: void, value: unknown): value is VerticalLineProperties;
+    type: AnnotationType.VerticalLine;
+    text: LineTextProperties;
+    getDefaultColor(): string | undefined;
+    getDefaultOpacity(): number | undefined;
+    getLineDash(): PixelSize[] | undefined;
+    getLineCap(): _ModuleSupport.ShapeLineCap | undefined;
+}
+export type CrossLineProperties = HorizontalLineProperties | VerticalLineProperties;
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/cross-line/crossLineScene.d.ts

@@ -0,0 +1,48 @@
+import { type Point } from 'ag-charts-core';
+import type { AnnotationContext } from '../annotationTypes';
+import { AnnotationScene } from '../scenes/annotationScene';
+import { CollidableText } from '../scenes/collidableTextScene';
+import { type CrossLineProperties } from './crossLineProperties';
+export declare class CrossLineScene extends AnnotationScene {
+    static is(value: unknown): value is CrossLineScene;
+    type: string;
+    activeHandle?: 'middle';
+    private readonly line;
+    private readonly middle;
+    private axisLabel?;
+    text?: CollidableText;
+    private seriesRect?;
+    private dragState?;
+    private isHorizontal;
+    constructor();
+    update(datum: CrossLineProperties, context: AnnotationContext): void;
+    private updateLine;
+    private updateHandle;
+    private updateText;
+    private createAxisLabel;
+    private updateAxisLabel;
+    setAxisLabelOpacity(opacity: number): void;
+    setAxisLabelVisible(visible: boolean): void;
+    toggleHandles(show: boolean): void;
+    destroy(): void;
+    toggleActive(active: boolean): void;
+    dragStart(datum: CrossLineProperties, target: Point, context: AnnotationContext): void;
+    drag(datum: CrossLineProperties, target: Point, context: AnnotationContext): void;
+    translate(datum: CrossLineProperties, translation: Point, context: AnnotationContext): void;
+    protected translatePoint(datum: CrossLineProperties, value: Point, translation: Point, context: AnnotationContext): void;
+    stopDragging(): void;
+    copy(datum: CrossLineProperties, copiedDatum: CrossLineProperties, context: AnnotationContext): CrossLineProperties | undefined;
+    getCursor(): "pointer" | "col-resize" | "row-resize" | undefined;
+    containsPoint(x: number, y: number): boolean;
+    getNodeAtCoords(x: number, y: number): "line" | "text" | "handle" | undefined;
+    getAnchor(): {
+        x: number;
+        y: number;
+        position?: undefined;
+    } | {
+        x: number;
+        y: number;
+        position: "right";
+    };
+    private convertCrossLine;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/cross-line/crossLineState.d.ts

@@ -0,0 +1,15 @@
+import { type Direction } from 'ag-charts-community';
+import { Debug, StateMachine } from 'ag-charts-core';
+import type { AnnotationsCreateStateMachineContext } from '../annotationsSuperTypes';
+import type { AnnotationStateEvents } from '../states/stateTypes';
+import { type CrossLineProperties } from './crossLineProperties';
+import type { CrossLineScene } from './crossLineScene';
+interface CrossLineStateMachineContext extends Omit<AnnotationsCreateStateMachineContext, 'create'> {
+    create: (datum: CrossLineProperties) => void;
+}
+export declare class CrossLineStateMachine extends StateMachine<'start' | 'waiting-first-render', Pick<AnnotationStateEvents, 'click' | 'drag' | 'cancel' | 'render' | 'reset'>> {
+    debug: Debug.DebugLogger;
+    protected node?: CrossLineScene;
+    constructor(direction: Direction, ctx: CrossLineStateMachineContext);
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/disjoint-channel/disjointChannelConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { DisjointChannelProperties } from './disjointChannelProperties';
+import { DisjointChannelScene } from './disjointChannelScene';
+export declare const disjointChannelConfig: AnnotationTypeConfig<DisjointChannelProperties, DisjointChannelScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/disjoint-channel/disjointChannelProperties.d.ts

@@ -0,0 +1,94 @@
+import { type PixelSize, _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties } from 'ag-charts-core';
+import { ChannelTextProperties } from '../annotationProperties';
+import { type AnnotationOptionsColorPickerType, AnnotationType } from '../annotationTypes';
+declare const DisjointChannelProperties_base: (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType, isMultiColor?: boolean | undefined): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & {
+    new (...args: any[]): {
+        background: {
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        start: import("../annotationProperties").PointProperties;
+        end: import("../annotationProperties").PointProperties;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        extendStart?: boolean | undefined;
+        extendEnd?: boolean | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+    };
+} & typeof BaseProperties;
+export declare class DisjointChannelProperties extends DisjointChannelProperties_base {
+    static is(this: void, value: unknown): value is DisjointChannelProperties;
+    type: AnnotationType.DisjointChannel;
+    startHeight: number;
+    endHeight: number;
+    text: ChannelTextProperties;
+    snapToAngle: number;
+    get bottom(): {
+        start: {
+            x: import("../utils/scale").PointType;
+            y: import("../utils/scale").PointType;
+        };
+        end: {
+            x: import("../utils/scale").PointType;
+            y: import("../utils/scale").PointType;
+        };
+    };
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getLineDash(): PixelSize[] | undefined;
+    getLineCap(): _ModuleSupport.ShapeLineCap | undefined;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/disjoint-channel/disjointChannelScene.d.ts

@@ -0,0 +1,30 @@
+import { type Bounds4, type Point } from 'ag-charts-core';
+import type { AnnotationContext } from '../annotationTypes';
+import { ChannelScene } from '../scenes/channelScene';
+import { DivariantHandle, UnivariantHandle } from '../scenes/handle';
+import type { DisjointChannelProperties } from './disjointChannelProperties';
+type ChannelHandle = keyof DisjointChannelScene['handles'];
+export declare class DisjointChannelScene extends ChannelScene<DisjointChannelProperties> {
+    static is(value: unknown): value is DisjointChannelScene;
+    type: string;
+    activeHandle?: ChannelHandle;
+    handles: {
+        topLeft: DivariantHandle;
+        topRight: DivariantHandle;
+        bottomLeft: DivariantHandle;
+        bottomRight: UnivariantHandle;
+    };
+    constructor();
+    dragHandle(datum: DisjointChannelProperties, target: Point, context: AnnotationContext, snapping: boolean): void;
+    protected getTranslatePointsVectors(start: Point, end: Point): {
+        start: Point;
+        end: Point;
+        bottomStart: Point;
+        bottomEnd: Point;
+    };
+    updateLines(datum: DisjointChannelProperties, top: Bounds4, bottom: Bounds4): void;
+    updateHandles(datum: DisjointChannelProperties, top: Bounds4, bottom: Bounds4): void;
+    updateText(datum: DisjointChannelProperties, top: Bounds4, bottom: Bounds4): void;
+    getBackgroundPoints(datum: DisjointChannelProperties, top: Bounds4, bottom: Bounds4, bounds: Bounds4): [Point, Point];
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/disjoint-channel/disjointChannelState.d.ts

@@ -0,0 +1,16 @@
+import { Debug, StateMachine } from 'ag-charts-core';
+import type { AnnotationsCreateStateMachineContext } from '../annotationsSuperTypes';
+import type { AnnotationStateEvents } from '../states/stateTypes';
+import { DisjointChannelProperties } from './disjointChannelProperties';
+import type { DisjointChannelScene } from './disjointChannelScene';
+interface DisjointChannelStateMachineContext extends Omit<AnnotationsCreateStateMachineContext, 'create'> {
+    create: (datum: DisjointChannelProperties) => void;
+}
+export declare class DisjointChannelStateMachine extends StateMachine<'start' | 'waiting-first-render' | 'end' | 'height', Pick<AnnotationStateEvents, 'click' | 'hover' | 'keyDown' | 'keyUp' | 'drag' | 'dragEnd' | 'cancel' | 'reset' | 'render'>> {
+    debug: Debug.DebugLogger;
+    protected datum?: DisjointChannelProperties;
+    protected node?: DisjointChannelScene;
+    protected snapping: boolean;
+    constructor(ctx: DisjointChannelStateMachineContext);
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { FibonacciRetracementTrendBasedProperties } from './fibonacciRetracementTrendBasedProperties';
+import { FibonacciRetracementTrendBasedScene } from './fibonacciRetracementTrendBasedScene';
+export declare const fibonacciRetracementTrendBasedConfig: AnnotationTypeConfig<FibonacciRetracementTrendBasedProperties, FibonacciRetracementTrendBasedScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedProperties.d.ts

@@ -0,0 +1,8 @@
+import { PointProperties } from '../annotationProperties';
+import { AnnotationType } from '../annotationTypes';
+import { FibonacciProperties } from '../properties/fibonacciProperties';
+export declare class FibonacciRetracementTrendBasedProperties extends FibonacciProperties {
+    static is(this: void, value: unknown): value is FibonacciRetracementTrendBasedProperties;
+    type: AnnotationType.FibonacciRetracementTrendBased;
+    endRetracement: PointProperties;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedScene.d.ts

@@ -0,0 +1,49 @@
+import type { Bounds4, BoxBounds, Point } from 'ag-charts-core';
+import type { PointProperties } from '../annotationProperties';
+import type { AnnotationContext } from '../annotationTypes';
+import { FibonacciScene } from '../scenes/fibonacciScene';
+import { DivariantHandle } from '../scenes/handle';
+import type { StartEndHandle } from '../scenes/startEndScene';
+import type { FibonacciRetracementTrendBasedProperties } from './fibonacciRetracementTrendBasedProperties';
+type ActiveHandle = StartEndHandle | 'endRetracement';
+export declare class FibonacciRetracementTrendBasedScene extends FibonacciScene<FibonacciRetracementTrendBasedProperties> {
+    static is(value: unknown): value is FibonacciRetracementTrendBasedScene;
+    type: string;
+    activeHandle?: ActiveHandle;
+    private readonly endRetracementLine;
+    protected readonly start: DivariantHandle;
+    protected readonly end: DivariantHandle;
+    protected readonly endRetracement: DivariantHandle;
+    protected readonly ignoreYBounds?: boolean;
+    protected dragState?: {
+        offset: Point;
+        start: Point;
+        end: Point;
+        endRetracement: Point;
+    };
+    constructor();
+    update(datum: FibonacciRetracementTrendBasedProperties, context: AnnotationContext): void;
+    containsPoint(x: number, y: number): boolean;
+    getNodeAtCoords(x: number, y: number): string | undefined;
+    dragStart(datum: FibonacciRetracementTrendBasedProperties, target: Point, context: AnnotationContext): void;
+    stopDragging(): void;
+    protected dragAll(datum: FibonacciRetracementTrendBasedProperties, target: Point, context: AnnotationContext): void;
+    dragHandle(datum: FibonacciRetracementTrendBasedProperties, target: Point, context: AnnotationContext, snapping: boolean): void;
+    snapToAngle(datum: FibonacciRetracementTrendBasedProperties, coords: Point, context: AnnotationContext): Pick<PointProperties, 'x' | 'y'> | undefined;
+    translatePoints({ datum, start, end, endRetracement, translation, context, }: {
+        datum: FibonacciRetracementTrendBasedProperties;
+        start: Point;
+        end: Point;
+        endRetracement: Point;
+        translation: Point;
+        context: AnnotationContext;
+    }): void;
+    translate(datum: FibonacciRetracementTrendBasedProperties, translation: Point, context: AnnotationContext): void;
+    copy(datum: FibonacciRetracementTrendBasedProperties, copiedDatum: FibonacciRetracementTrendBasedProperties, context: AnnotationContext): FibonacciRetracementTrendBasedProperties | undefined;
+    private getCoords;
+    toggleHandles(show: boolean | Partial<Record<ActiveHandle, boolean>>): void;
+    toggleActive(active: boolean): void;
+    protected updateHandles(datum: FibonacciRetracementTrendBasedProperties, coords1: Bounds4, coords2?: Bounds4, bbox?: BoxBounds): void;
+    protected getHandleCoords(_datum: FibonacciRetracementTrendBasedProperties, coords: Bounds4, handle: ActiveHandle, _bbox?: BoxBounds): Point;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement-trend-based/fibonacciRetracementTrendBasedState.d.ts

@@ -0,0 +1,17 @@
+import { Debug, StateMachine } from 'ag-charts-core';
+import type { AnnotationsCreateStateMachineContext } from '../annotationsSuperTypes';
+import type { AnnotationStateEvents } from '../states/stateTypes';
+import { FibonacciRetracementTrendBasedProperties } from './fibonacciRetracementTrendBasedProperties';
+import type { FibonacciRetracementTrendBasedScene } from './fibonacciRetracementTrendBasedScene';
+interface FibonacciRetracementTrendBasedStateMachineContext extends Omit<AnnotationsCreateStateMachineContext, 'create'> {
+    create: (datum: FibonacciRetracementTrendBasedProperties) => void;
+}
+export declare class FibonacciRetracementTrendBasedStateMachine extends StateMachine<'start' | 'waiting-first-render' | 'end' | 'endRetracement', Pick<AnnotationStateEvents, 'click' | 'hover' | 'keyDown' | 'keyUp' | 'drag' | 'dragEnd' | 'reset' | 'cancel' | 'render'>> {
+    debug: Debug.DebugLogger;
+    protected datum?: FibonacciRetracementTrendBasedProperties;
+    protected node?: FibonacciRetracementTrendBasedScene;
+    protected snapping: boolean;
+    constructor(ctx: FibonacciRetracementTrendBasedStateMachineContext);
+    createDatum(): FibonacciRetracementTrendBasedProperties;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement/fibonacciRetracementConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { FibonacciRetracementProperties } from './fibonacciRetracementProperties';
+import { FibonacciRetracementScene } from './fibonacciRetracementScene';
+export declare const fibonacciRetracementConfig: AnnotationTypeConfig<FibonacciRetracementProperties, FibonacciRetracementScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement/fibonacciRetracementProperties.d.ts

@@ -0,0 +1,6 @@
+import { AnnotationType } from '../annotationTypes';
+import { FibonacciProperties } from '../properties/fibonacciProperties';
+export declare class FibonacciRetracementProperties extends FibonacciProperties {
+    static is(this: void, value: unknown): value is FibonacciRetracementProperties;
+    type: AnnotationType.FibonacciRetracement;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement/fibonacciRetracementScene.d.ts

@@ -0,0 +1,41 @@
+import type { Bounds4, BoxBounds, Point } from 'ag-charts-core';
+import type { PointProperties } from '../annotationProperties';
+import type { AnnotationContext } from '../annotationTypes';
+import { FibonacciScene } from '../scenes/fibonacciScene';
+import { DivariantHandle } from '../scenes/handle';
+import type { StartEndHandle } from '../scenes/startEndScene';
+import type { FibonacciRetracementProperties } from './fibonacciRetracementProperties';
+export declare class FibonacciRetracementScene extends FibonacciScene<FibonacciRetracementProperties> {
+    static is(value: unknown): value is FibonacciRetracementScene;
+    type: string;
+    activeHandle?: StartEndHandle;
+    protected readonly start: DivariantHandle;
+    protected readonly end: DivariantHandle;
+    protected readonly ignoreYBounds?: boolean;
+    protected dragState?: {
+        offset: Point;
+        start: Point;
+        end: Point;
+    };
+    constructor();
+    containsPoint(x: number, y: number): boolean;
+    getNodeAtCoords(x: number, y: number): string | undefined;
+    dragStart(datum: FibonacciRetracementProperties, target: Point, context: AnnotationContext): void;
+    stopDragging(): void;
+    protected dragAll(datum: FibonacciRetracementProperties, target: Point, context: AnnotationContext): void;
+    dragHandle(datum: FibonacciRetracementProperties, target: Point, context: AnnotationContext, snapping: boolean): void;
+    snapToAngle(datum: FibonacciRetracementProperties, coords: Point, context: AnnotationContext): Pick<PointProperties, 'x' | 'y'> | undefined;
+    translatePoints({ datum, start, end, translation, context, }: {
+        datum: FibonacciRetracementProperties;
+        start: Point;
+        end: Point;
+        translation: Point;
+        context: AnnotationContext;
+    }): void;
+    translate(datum: FibonacciRetracementProperties, translation: Point, context: AnnotationContext): void;
+    copy(datum: FibonacciRetracementProperties, copiedDatum: FibonacciRetracementProperties, context: AnnotationContext): FibonacciRetracementProperties | undefined;
+    toggleHandles(show: boolean | Partial<Record<StartEndHandle, boolean>>): void;
+    toggleActive(active: boolean): void;
+    protected updateHandles(datum: FibonacciRetracementProperties, coords: Bounds4, _coords2: Bounds4, bbox?: BoxBounds): void;
+    protected getHandleCoords(_datum: FibonacciRetracementProperties, coords: Bounds4, handle: StartEndHandle, _bbox?: BoxBounds): Point;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/fibonacci-retracement/fibonacciRetracementState.d.ts

@@ -0,0 +1,5 @@
+import { LineTypeStateMachine } from '../line/lineState';
+import { FibonacciRetracementProperties } from './fibonacciRetracementProperties';
+export declare class FibonacciRetracementStateMachine extends LineTypeStateMachine<FibonacciRetracementProperties> {
+    createDatum(): FibonacciRetracementProperties;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/line/lineConfig.d.ts

@@ -0,0 +1,5 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { ArrowProperties, LineProperties } from './lineProperties';
+import { LineScene } from './lineScene';
+export declare const lineConfig: AnnotationTypeConfig<LineProperties, LineScene>;
+export declare const arrowConfig: AnnotationTypeConfig<ArrowProperties, LineScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/line/lineProperties.d.ts

@@ -0,0 +1,51 @@
+import { type PixelSize, _ModuleSupport } from 'ag-charts-community';
+import { LineTextProperties } from '../annotationProperties';
+import { type AnnotationOptionsColorPickerType, AnnotationType } from '../annotationTypes';
+import { StartEndProperties } from '../properties/startEndProperties';
+declare const LineTypeProperties_base: {
+    new (...args: any[]): {
+        localeManager?: import("packages/ag-charts-community/dist/types/src/locale/localeManager").LocaleManager | undefined;
+        setLocaleManager(localeManager: import("packages/ag-charts-community/dist/types/src/locale/localeManager").LocaleManager): void;
+    };
+} & {
+    new (...args: any[]): {
+        startCap?: "arrow" | undefined;
+        endCap?: "arrow" | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        extendStart?: boolean | undefined;
+        extendEnd?: boolean | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+    };
+} & typeof StartEndProperties;
+export declare abstract class LineTypeProperties extends LineTypeProperties_base {
+    text: LineTextProperties;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(): number | undefined;
+    getLineDash(): PixelSize[] | undefined;
+    getLineCap(): _ModuleSupport.ShapeLineCap | undefined;
+}
+export declare class ArrowProperties extends LineTypeProperties {
+    static is(this: void, value: unknown): value is ArrowProperties;
+    type: AnnotationType.Arrow;
+    endCap: "arrow";
+}
+export declare class LineProperties extends LineTypeProperties {
+    static is(this: void, value: unknown): value is LineProperties;
+    type: AnnotationType.Line;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/line/lineScene.d.ts

@@ -0,0 +1,28 @@
+import type { Bounds4, BoxBounds, Point } from 'ag-charts-core';
+import type { AnnotationContext } from '../annotationTypes';
+import { CollidableText } from '../scenes/collidableTextScene';
+import { StartEndScene } from '../scenes/startEndScene';
+import type { LineTypeProperties } from './lineProperties';
+export declare class LineScene extends StartEndScene<LineTypeProperties> {
+    static is(value: unknown): value is LineScene;
+    type: string;
+    private readonly line;
+    text?: CollidableText;
+    private startCap?;
+    private endCap?;
+    constructor();
+    update(datum: LineTypeProperties, context: AnnotationContext): void;
+    private updateLine;
+    private updateText;
+    private updateCaps;
+    updateAnchor(_datum: LineTypeProperties, coords: Bounds4, _context: AnnotationContext, _bbox?: BoxBounds): void;
+    containsPoint(x: number, y: number): boolean;
+    getNodeAtCoords(x: number, y: number): string | undefined;
+    protected getHandleCoords(_datum: LineTypeProperties, coords: Bounds4, handle: 'start' | 'end', _bbox?: BoxBounds): Point;
+    protected getHandleStyles(datum: LineTypeProperties): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    };
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/line/lineState.d.ts

@@ -0,0 +1,23 @@
+import { Debug, StateMachine } from 'ag-charts-core';
+import type { AnnotationsCreateStateMachineContext } from '../annotationsSuperTypes';
+import type { AnnotationStateEvents } from '../states/stateTypes';
+import { ArrowProperties, LineProperties, LineTypeProperties } from './lineProperties';
+import type { LineScene } from './lineScene';
+interface LineStateMachineContext<Datum extends LineTypeProperties> extends Omit<AnnotationsCreateStateMachineContext, 'create'> {
+    create: (datum: Datum) => void;
+}
+export declare abstract class LineTypeStateMachine<Datum extends LineTypeProperties> extends StateMachine<'start' | 'waiting-first-render' | 'end', Pick<AnnotationStateEvents, 'click' | 'hover' | 'keyDown' | 'keyUp' | 'drag' | 'dragEnd' | 'reset' | 'cancel' | 'render'>> {
+    debug: Debug.DebugLogger;
+    protected datum?: Datum;
+    protected node?: LineScene;
+    protected snapping: boolean;
+    constructor(ctx: LineStateMachineContext<Datum>);
+    abstract createDatum(): Datum;
+}
+export declare class ArrowStateMachine extends LineTypeStateMachine<ArrowProperties> {
+    createDatum(): ArrowProperties;
+}
+export declare class LineStateMachine extends LineTypeStateMachine<LineProperties> {
+    createDatum(): LineProperties;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/measurer/measurerConfig.d.ts

@@ -0,0 +1,7 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { DatePriceRangeProperties, DateRangeProperties, PriceRangeProperties, QuickDatePriceRangeProperties } from './measurerProperties';
+import { MeasurerScene, QuickMeasurerScene } from './measurerScene';
+export declare const dateRangeConfig: AnnotationTypeConfig<DateRangeProperties, MeasurerScene>;
+export declare const priceRangeConfig: AnnotationTypeConfig<PriceRangeProperties, MeasurerScene>;
+export declare const datePriceRangeConfig: AnnotationTypeConfig<DatePriceRangeProperties, MeasurerScene>;
+export declare const quickDatePriceRangeConfig: AnnotationTypeConfig<QuickDatePriceRangeProperties, QuickMeasurerScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/measurer/measurerProperties.d.ts

@@ -0,0 +1,169 @@
+import { type PixelSize, _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties } from 'ag-charts-core';
+import { LineTextProperties } from '../annotationProperties';
+import { type AnnotationOptionsColorPickerType, AnnotationType, type DataPoint } from '../annotationTypes';
+import { StartEndProperties } from '../properties/startEndProperties';
+declare const MeasurerStatisticsDivider_base: {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & typeof BaseProperties;
+declare class MeasurerStatisticsDivider extends MeasurerStatisticsDivider_base {
+}
+declare const MeasurerStatistics_base: {
+    new (...args: any[]): {
+        fontStyle?: import("ag-charts-community").FontStyle | undefined;
+        fontWeight?: import("ag-charts-community").FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & typeof BaseProperties;
+declare class MeasurerStatistics extends MeasurerStatistics_base {
+    divider: MeasurerStatisticsDivider;
+}
+declare const MeasurerDirectionProperties_base: {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & typeof BaseProperties;
+declare class MeasurerDirectionProperties extends MeasurerDirectionProperties_base {
+    statistics: MeasurerStatistics;
+}
+declare const MeasurerTypeProperties_base: {
+    new (...args: any[]): {
+        localeManager?: import("packages/ag-charts-community/dist/types/src/locale/localeManager").LocaleManager | undefined;
+        setLocaleManager(localeManager: import("packages/ag-charts-community/dist/types/src/locale/localeManager").LocaleManager): void;
+    };
+} & {
+    new (...args: any[]): {
+        background: {
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+    };
+} & typeof StartEndProperties;
+export declare class MeasurerTypeProperties extends MeasurerTypeProperties_base {
+    direction: 'both' | 'horizontal' | 'vertical';
+    hasDateRange: boolean;
+    hasPriceRange: boolean;
+    statistics: MeasurerStatistics;
+    getVolume: (from: DataPoint['x'], to: DataPoint['x']) => number | undefined;
+    text: LineTextProperties;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getLineDash(): PixelSize[] | undefined;
+    getLineCap(): _ModuleSupport.ShapeLineCap | undefined;
+}
+declare const DateRangeProperties_base: {
+    new (...args: any[]): {
+        hasDateRange: boolean;
+    };
+} & typeof MeasurerTypeProperties;
+export declare class DateRangeProperties extends DateRangeProperties_base {
+    static is(this: void, value: unknown): value is DateRangeProperties;
+    type: AnnotationType.DateRange;
+    extendAbove?: boolean;
+    extendBelow?: boolean;
+    direction: "horizontal";
+}
+declare const PriceRangeProperties_base: {
+    new (...args: any[]): {
+        hasPriceRange: boolean;
+    };
+} & typeof MeasurerTypeProperties;
+export declare class PriceRangeProperties extends PriceRangeProperties_base {
+    static is(this: void, value: unknown): value is PriceRangeProperties;
+    type: AnnotationType.PriceRange;
+    extendLeft?: boolean;
+    extendRight?: boolean;
+    direction: "vertical";
+}
+declare const DatePriceRangeProperties_base: {
+    new (...args: any[]): {
+        hasDateRange: boolean;
+    };
+} & {
+    new (...args: any[]): {
+        hasPriceRange: boolean;
+    };
+} & typeof MeasurerTypeProperties;
+export declare class DatePriceRangeProperties extends DatePriceRangeProperties_base {
+    static is(this: void, value: unknown): value is DatePriceRangeProperties;
+    type: AnnotationType.DatePriceRange;
+    direction: "both";
+}
+declare const QuickDatePriceRangeProperties_base: {
+    new (...args: any[]): {
+        hasDateRange: boolean;
+    };
+} & {
+    new (...args: any[]): {
+        hasPriceRange: boolean;
+    };
+} & typeof MeasurerTypeProperties;
+export declare class QuickDatePriceRangeProperties extends QuickDatePriceRangeProperties_base {
+    static is(this: void, value: unknown): value is QuickDatePriceRangeProperties;
+    type: AnnotationType.QuickDatePriceRange;
+    up: MeasurerDirectionProperties;
+    down: MeasurerDirectionProperties;
+    direction: "both";
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/measurer/measurerScene.d.ts

@@ -0,0 +1,87 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { type Bounds4 } from 'ag-charts-core';
+import type { AnnotationContext } from '../annotationTypes';
+import { CollidableText } from '../scenes/collidableTextScene';
+import { StartEndScene } from '../scenes/startEndScene';
+import { type MeasurerTypeProperties, QuickDatePriceRangeProperties } from './measurerProperties';
+import { MeasurerStatisticsScene, QuickMeasurerStatisticsScene } from './measurerStatisticsScene';
+export declare class MeasurerScene extends StartEndScene<MeasurerTypeProperties> {
+    static is(value: unknown): value is MeasurerScene;
+    type: string;
+    private readonly horizontalLine;
+    private readonly verticalLine;
+    text?: CollidableText;
+    private readonly horizontalStartLine;
+    private readonly horizontalEndLine;
+    private readonly verticalStartLine;
+    private readonly verticalEndLine;
+    private readonly horizontalEndCap;
+    private readonly verticalEndCap;
+    readonly background: _ModuleSupport.Path<any>;
+    private readonly statistics;
+    protected verticalDirection?: 'up' | 'down';
+    constructor();
+    protected createStatisticsScene(): MeasurerStatisticsScene;
+    update(datum: MeasurerTypeProperties, context: AnnotationContext): void;
+    private extendPerpendicular;
+    private updateVisibilities;
+    private updateLines;
+    private updateText;
+    private updateCaps;
+    private updateBoundingLines;
+    private readonly updateBackground;
+    private updateStatistics;
+    updateAnchor(_datum: MeasurerTypeProperties, coords: Bounds4, _context: AnnotationContext, _bbox?: _ModuleSupport.BBox): void;
+    getBackgroundPoints(_datum: MeasurerTypeProperties, verticalStart: Bounds4, verticalEnd: Bounds4, _bounds: Bounds4): import("ag-charts-core").Point[];
+    protected getLineStyles(datum: MeasurerTypeProperties): {
+        lineCap: _ModuleSupport.ShapeLineCap | undefined;
+        lineDash: number[] | undefined;
+        lineDashOffset: number | undefined;
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        strokeOpacity: number | undefined;
+        fillOpacity: number;
+    };
+    getBackgroundStyles(datum: MeasurerTypeProperties): {
+        fill: string | undefined;
+        fillOpacity: number | undefined;
+    };
+    getHandleStyles(datum: MeasurerTypeProperties): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    };
+    containsPoint(x: number, y: number): boolean;
+    getNodeAtCoords(x: number, y: number): string | undefined;
+    private getDateRangeBars;
+    private getDateRangeValue;
+    private getPriceRangePercentage;
+    private getPriceRangeValue;
+    private getVolume;
+}
+export declare class QuickMeasurerScene extends MeasurerScene {
+    static is(value: unknown): value is QuickMeasurerScene;
+    type: string;
+    createStatisticsScene(): QuickMeasurerStatisticsScene;
+    private getDirectionStyles;
+    getLineStyles(datum: QuickDatePriceRangeProperties): {
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        strokeOpacity: number | undefined;
+        lineCap: _ModuleSupport.ShapeLineCap | undefined;
+        lineDash: number[] | undefined;
+        lineDashOffset: number | undefined;
+        fillOpacity: number;
+    };
+    getBackgroundStyles(datum: QuickDatePriceRangeProperties): {
+        fill: string | undefined;
+        fillOpacity: number | undefined;
+    };
+    getHandleStyles(datum: QuickDatePriceRangeProperties): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    };
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/measurer/measurerState.d.ts

@@ -0,0 +1,28 @@
+import { Debug, StateMachine } from 'ag-charts-core';
+import type { AnnotationsCreateStateMachineContext, MeasurerPropertiesType } from '../annotationsSuperTypes';
+import type { AnnotationStateEvents } from '../states/stateTypes';
+import { DatePriceRangeProperties, DateRangeProperties, PriceRangeProperties, QuickDatePriceRangeProperties } from './measurerProperties';
+import type { MeasurerScene } from './measurerScene';
+interface MeasurerStateMachineContext<Datum extends MeasurerPropertiesType> extends Omit<AnnotationsCreateStateMachineContext, 'create'> {
+    create: (datum: Datum) => void;
+}
+declare abstract class MeasurerTypeStateMachine<Datum extends MeasurerPropertiesType> extends StateMachine<'start' | 'end', Pick<AnnotationStateEvents, 'click' | 'hover' | 'drag' | 'dragEnd' | 'reset' | 'cancel'>> {
+    debug: Debug.DebugLogger;
+    protected datum?: Datum;
+    protected node?: MeasurerScene;
+    constructor(ctx: MeasurerStateMachineContext<Datum>);
+    abstract createDatum(): Datum;
+}
+export declare class DateRangeStateMachine extends MeasurerTypeStateMachine<DateRangeProperties> {
+    createDatum(): DateRangeProperties;
+}
+export declare class PriceRangeStateMachine extends MeasurerTypeStateMachine<PriceRangeProperties> {
+    createDatum(): PriceRangeProperties;
+}
+export declare class DatePriceRangeStateMachine extends MeasurerTypeStateMachine<DatePriceRangeProperties> {
+    createDatum(): DatePriceRangeProperties;
+}
+export declare class QuickDatePriceRangeStateMachine extends MeasurerTypeStateMachine<QuickDatePriceRangeProperties> {
+    createDatum(): QuickDatePriceRangeProperties;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/measurer/measurerStatisticsScene.d.ts

@@ -0,0 +1,82 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { type Bounds4, type Point } from 'ag-charts-core';
+import type { AnnotationContext } from '../annotationTypes';
+import type { MeasurerTypeProperties, QuickDatePriceRangeProperties } from './measurerProperties';
+export interface Statistics {
+    dateRange?: {
+        bars: number;
+        value: number;
+    };
+    priceRange?: {
+        percentage: number;
+        value: number;
+    };
+    volume?: number;
+}
+export declare class MeasurerStatisticsScene extends _ModuleSupport.Group {
+    name: string;
+    private readonly background;
+    private readonly dateRangeBarsText;
+    private readonly dateRangeDivider;
+    private readonly dateRangeValueText;
+    private readonly priceRangeValueText;
+    private readonly priceRangeDivider;
+    private readonly priceRangePercentageText;
+    private readonly volumeText;
+    private readonly volumeFormatter;
+    protected verticalDirection?: 'up' | 'down';
+    constructor();
+    update(datum: MeasurerTypeProperties, stats: Statistics, anchor: Point, coords: Bounds4, context: AnnotationContext, verticalDirection?: 'up' | 'down', localeManager?: _ModuleSupport.ModuleContext['localeManager']): void;
+    private checkVisibility;
+    private updateStatistics;
+    private updateBackground;
+    private reposition;
+    protected getTextStyles(datum: MeasurerTypeProperties): {
+        fill: string | undefined;
+        fontFamily: string;
+        fontSize: number;
+        fontStyle: import("ag-charts-community").FontStyle | undefined;
+        fontWeight: import("ag-charts-community").FontWeight | undefined;
+        textBaseline: "top";
+    };
+    protected getDividerStyles(datum: MeasurerTypeProperties): {
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    };
+    protected getBackgroundStyles(datum: MeasurerTypeProperties): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+        cornerRadius: number;
+    };
+    private formatDateRangeBars;
+    private formatDateRangeValue;
+    private formatPriceRangeValue;
+    private formatPriceRangePercentage;
+    private formatVolume;
+}
+export declare class QuickMeasurerStatisticsScene extends MeasurerStatisticsScene {
+    private getDirectionStyles;
+    getTextStyles(datum: QuickDatePriceRangeProperties): {
+        fill: string | undefined;
+        fontFamily: string;
+        fontSize: number;
+        fontStyle: import("ag-charts-community").FontStyle | undefined;
+        fontWeight: import("ag-charts-community").FontWeight | undefined;
+        textBaseline: "top";
+    };
+    getDividerStyles(datum: QuickDatePriceRangeProperties): {
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    };
+    getBackgroundStyles(datum: QuickDatePriceRangeProperties): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+        cornerRadius: number;
+    };
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/note/noteConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { NoteProperties } from './noteProperties';
+import { NoteScene } from './noteScene';
+export declare const noteConfig: AnnotationTypeConfig<NoteProperties, NoteScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/note/noteProperties.d.ts

@@ -0,0 +1,50 @@
+import { BaseProperties } from 'ag-charts-core';
+import { type AnnotationContext, type AnnotationOptionsColorPickerType, AnnotationType, type Padding } from '../annotationTypes';
+import { TextualPointProperties } from '../properties/textualPointProperties';
+export declare const ICON_HEIGHT = 20;
+export declare const ICON_WIDTH = 22;
+export declare const LABEL_OFFSET: number;
+export declare const TOOLBAR_OFFSET = 34;
+declare const NoteBackgroundProperties_base: {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & typeof BaseProperties;
+declare class NoteBackgroundProperties extends NoteBackgroundProperties_base {
+}
+declare const NoteProperties_base: {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & typeof TextualPointProperties;
+export declare class NoteProperties extends NoteProperties_base {
+    static is(this: void, value: unknown): value is NoteProperties;
+    type: AnnotationType.Note;
+    background: NoteBackgroundProperties;
+    position: 'bottom' | 'top';
+    alignment: "center";
+    width: number;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getPadding(): Padding;
+    getTextInputCoords(context: AnnotationContext, height: number): {
+        x: number;
+        y: number;
+    };
+    isHoverable(): boolean;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/note/noteScene.d.ts

@@ -0,0 +1,36 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { type BoxBounds, type Point } from 'ag-charts-core';
+import { type AnnotationContext, AnnotationType } from '../annotationTypes';
+import { TextualPointScene } from '../scenes/textualPointScene';
+import { type NoteProperties } from './noteProperties';
+export declare class NoteScene extends TextualPointScene<NoteProperties> {
+    static is(value: unknown): value is NoteScene;
+    type: AnnotationType;
+    private readonly shape;
+    private readonly iconBackground;
+    private readonly iconLines;
+    private active;
+    constructor();
+    update(datum: NoteProperties, context: AnnotationContext): void;
+    getTextBBox(datum: NoteProperties, coords: Point, context: AnnotationContext): _ModuleSupport.BBox;
+    updateLabel(datum: NoteProperties, bbox: BoxBounds): void;
+    updateShape(datum: NoteProperties, bbox: BoxBounds): void;
+    private updateIcon;
+    protected updateAnchor(datum: NoteProperties, bbox: BoxBounds, context: AnnotationContext): {
+        x: number;
+        y: number;
+        position: "above" | "below";
+    };
+    protected getLabelCoords(datum: NoteProperties, bbox: BoxBounds): Point;
+    protected getTextBaseline(datum: NoteProperties): CanvasTextBaseline;
+    protected getHandleCoords(_datum: NoteProperties, coords: Point, _bbox: BoxBounds): Point;
+    protected getHandleStyles(datum: NoteProperties): {
+        fill: string | undefined;
+        stroke: string | undefined;
+        strokeOpacity: number | undefined;
+        strokeWidth: number | undefined;
+    };
+    toggleHovered(hovered: boolean, active: boolean, readOnly: boolean | undefined): void;
+    toggleActive(active: boolean): void;
+    containsPoint(x: number, y: number): boolean;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/note/noteState.d.ts

@@ -0,0 +1,6 @@
+import { TextualPointStateMachine } from '../states/textualPointState';
+import { NoteProperties } from './noteProperties';
+import type { NoteScene } from './noteScene';
+export declare class NoteStateMachine extends TextualPointStateMachine<NoteProperties, NoteScene> {
+    protected createDatum(): NoteProperties;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/parallel-channel/parallelChannelConfig.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationTypeConfig } from '../annotationsSuperTypes';
+import { ParallelChannelProperties } from './parallelChannelProperties';
+import { ParallelChannelScene } from './parallelChannelScene';
+export declare const parallelChannelConfig: AnnotationTypeConfig<ParallelChannelProperties, ParallelChannelScene>;

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/parallel-channel/parallelChannelProperties.d.ts

@@ -0,0 +1,94 @@
+import { type PixelSize, _ModuleSupport } from 'ag-charts-community';
+import { BaseProperties } from 'ag-charts-core';
+import { ChannelAnnotationMiddleProperties, ChannelTextProperties } from '../annotationProperties';
+import { type AnnotationOptionsColorPickerType, AnnotationType } from '../annotationTypes';
+declare const ParallelChannelProperties_base: (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType, isMultiColor?: boolean | undefined): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & {
+    new (...args: any[]): {
+        background: {
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        start: import("../annotationProperties").PointProperties;
+        end: import("../annotationProperties").PointProperties;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        extendStart?: boolean | undefined;
+        extendEnd?: boolean | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        stroke?: string | undefined;
+        strokeOpacity?: number | undefined;
+        strokeWidth?: number | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        lineCap?: _ModuleSupport.ShapeLineCap | undefined;
+        computedLineDash?: number[] | undefined;
+        lineDash?: number[] | undefined;
+        lineDashOffset?: number | undefined;
+        lineStyle?: import("ag-charts-community").AgAnnotationLineStyleType | undefined;
+    };
+} & typeof BaseProperties;
+export declare class ParallelChannelProperties extends ParallelChannelProperties_base {
+    static is(this: void, value: unknown): value is ParallelChannelProperties;
+    type: AnnotationType.ParallelChannel;
+    height: number;
+    middle: ChannelAnnotationMiddleProperties;
+    text: ChannelTextProperties;
+    snapToAngle: number;
+    get bottom(): {
+        start: {
+            x: import("../utils/scale").PointType;
+            y: import("../utils/scale").PointType;
+        };
+        end: {
+            x: import("../utils/scale").PointType;
+            y: import("../utils/scale").PointType;
+        };
+    };
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getLineDash(): PixelSize[] | undefined;
+    getLineCap(): _ModuleSupport.ShapeLineCap | undefined;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/parallel-channel/parallelChannelScene.d.ts

@@ -0,0 +1,35 @@
+import { type Bounds4, type Point } from 'ag-charts-core';
+import type { AnnotationContext } from '../annotationTypes';
+import { ChannelScene } from '../scenes/channelScene';
+import { DivariantHandle, UnivariantHandle } from '../scenes/handle';
+import type { ParallelChannelProperties } from './parallelChannelProperties';
+type ChannelHandle = keyof ParallelChannelScene['handles'];
+export declare class ParallelChannelScene extends ChannelScene<ParallelChannelProperties> {
+    static is(value: unknown): value is ParallelChannelScene;
+    type: string;
+    activeHandle?: ChannelHandle;
+    handles: {
+        topLeft: DivariantHandle;
+        topMiddle: UnivariantHandle;
+        topRight: DivariantHandle;
+        bottomLeft: DivariantHandle;
+        bottomMiddle: UnivariantHandle;
+        bottomRight: DivariantHandle;
+    };
+    private readonly middleLine;
+    constructor();
+    dragHandle(datum: ParallelChannelProperties, target: Point, context: AnnotationContext, snapping: boolean): void;
+    protected getTranslatePointsVectors(start: Point, end: Point): {
+        start: Point;
+        end: Point;
+        bottomStart: Point;
+        bottomEnd: Point;
+    };
+    containsPoint(x: number, y: number): boolean;
+    getNodeAtCoords(x: number, y: number): string | undefined;
+    updateLines(datum: ParallelChannelProperties, top: Bounds4, bottom: Bounds4, context: AnnotationContext, naturalTop: Bounds4, naturalBottom: Bounds4): void;
+    updateHandles(datum: ParallelChannelProperties, top: Bounds4, bottom: Bounds4): void;
+    updateText(datum: ParallelChannelProperties, top: Bounds4, bottom: Bounds4): void;
+    getBackgroundPoints(datum: ParallelChannelProperties, top: Bounds4, bottom: Bounds4, bounds: Bounds4): [Point, Point];
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/parallel-channel/parallelChannelState.d.ts

@@ -0,0 +1,16 @@
+import { Debug, StateMachine } from 'ag-charts-core';
+import type { AnnotationsCreateStateMachineContext } from '../annotationsSuperTypes';
+import type { AnnotationStateEvents } from '../states/stateTypes';
+import { ParallelChannelProperties } from './parallelChannelProperties';
+import type { ParallelChannelScene } from './parallelChannelScene';
+interface ParallelChannelStateMachineContext extends Omit<AnnotationsCreateStateMachineContext, 'create'> {
+    create: (datum: ParallelChannelProperties) => void;
+}
+export declare class ParallelChannelStateMachine extends StateMachine<'start' | 'waiting-first-render' | 'end' | 'height', Pick<AnnotationStateEvents, 'click' | 'hover' | 'keyDown' | 'keyUp' | 'drag' | 'dragEnd' | 'cancel' | 'reset' | 'render'>> {
+    debug: Debug.DebugLogger;
+    protected datum?: ParallelChannelProperties;
+    protected node?: ParallelChannelScene;
+    protected snapping: boolean;
+    constructor(ctx: ParallelChannelStateMachineContext);
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/properties/fibonacciProperties.d.ts

@@ -0,0 +1,13 @@
+import { LabelTextProperties } from '../annotationProperties';
+import type { AnnotationOptionsColorPickerType, FibonacciBands } from '../annotationTypes';
+import { LineTypeProperties } from '../line/lineProperties';
+export declare class FibonacciProperties extends LineTypeProperties {
+    label: LabelTextProperties;
+    reverse: boolean;
+    showFill: boolean;
+    isMultiColor: boolean;
+    strokes: string[];
+    rangeStroke?: string;
+    bands?: FibonacciBands;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/properties/pointProperties.d.ts

@@ -0,0 +1,44 @@
+import { BaseProperties } from 'ag-charts-core';
+import { type AnnotationOptionsColorPickerType } from '../annotationTypes';
+declare const PointProperties_base: (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType, isMultiColor?: boolean | undefined): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & {
+    new (...args: any[]): {
+        x?: import("../utils/scale").PointType;
+        y?: import("../utils/scale").PointType;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: import("packages/ag-charts-community/dist/types/src/module-support").ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("packages/ag-charts-types/dist/types/src/main").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & typeof BaseProperties;
+export declare class PointProperties extends PointProperties_base {
+    getDefaultColor(_colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(_colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/properties/shapePointProperties.d.ts

@@ -0,0 +1,15 @@
+import { type AnnotationOptionsColorPickerType } from '../annotationTypes';
+import { PointProperties } from './pointProperties';
+declare const ShapePointProperties_base: {
+    new (...args: any[]): {
+        fill?: string | undefined;
+        fillOpacity?: number | undefined;
+    };
+} & typeof PointProperties;
+export declare class ShapePointProperties extends ShapePointProperties_base {
+    static is(value: unknown): value is ShapePointProperties;
+    size: number;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/properties/startEndProperties.d.ts

@@ -0,0 +1,45 @@
+import { BaseProperties } from 'ag-charts-core';
+import { type AnnotationOptionsColorPickerType } from '../annotationTypes';
+declare const StartEndProperties_base: (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType, isMultiColor?: boolean | undefined): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & {
+    new (...args: any[]): {
+        start: import("../annotationProperties").PointProperties;
+        end: import("../annotationProperties").PointProperties;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: import("packages/ag-charts-community/dist/types/src/module-support").ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("packages/ag-charts-types/dist/types/src/main").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & typeof BaseProperties;
+export declare class StartEndProperties extends StartEndProperties_base {
+    snapToAngle: number;
+    getDefaultColor(_colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(_colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/properties/textualPointProperties.d.ts

@@ -0,0 +1,76 @@
+import { BaseProperties } from 'ag-charts-core';
+import { type AnnotationContext, type AnnotationOptionsColorPickerType, type Padding } from '../annotationTypes';
+import type { AnnotationTextAlignment, AnnotationTextPosition } from '../text/util';
+declare const TextualPointProperties_base: (abstract new (...args: any[]) => {
+    id: string;
+    getDefaultColor(colorPickerType: AnnotationOptionsColorPickerType, isMultiColor?: boolean | undefined): string | undefined;
+    locked?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    isWriteable(): boolean;
+    isHoverable(): boolean;
+    visible?: boolean | undefined;
+    handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+    set(properties: object): any;
+    clear(): any;
+    toJson<J>(this: J): object;
+}) & {
+    new (...args: any[]): {
+        x?: import("../utils/scale").PointType;
+        y?: import("../utils/scale").PointType;
+    };
+} & {
+    new (...args: any[]): {
+        handle: {
+            stroke?: string | undefined;
+            strokeOpacity?: number | undefined;
+            strokeWidth?: number | undefined;
+            lineCap?: import("packages/ag-charts-community/dist/types/src/module-support").ShapeLineCap | undefined;
+            computedLineDash?: number[] | undefined;
+            lineDash?: number[] | undefined;
+            lineDashOffset?: number | undefined;
+            lineStyle?: import("packages/ag-charts-types/dist/types/src/main").AgAnnotationLineStyleType | undefined;
+            fill?: string | undefined;
+            fillOpacity?: number | undefined;
+            handleUnknownProperties(_unknownKeys: Set<unknown>, _properties: object): void;
+            set(properties: object): any;
+            clear(): any;
+            toJson<J>(this: J): object;
+        };
+    };
+} & {
+    new (...args: any[]): {
+        padding?: number | undefined;
+        textAlign: import("packages/ag-charts-types/dist/types/src/main").TextAlign;
+        formatter?: import("packages/ag-charts-types/dist/types/src/main").Formatter<import("../annotationProperties").AxisLabelFormatterParams> | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        fontStyle?: import("packages/ag-charts-types/dist/types/src/main").FontStyle | undefined;
+        fontWeight?: import("packages/ag-charts-types/dist/types/src/main").FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & typeof BaseProperties;
+export declare class TextualPointProperties extends TextualPointProperties_base {
+    text: string;
+    position: AnnotationTextPosition;
+    alignment: AnnotationTextAlignment;
+    placement: 'inside' | 'outside';
+    width?: number;
+    placeholderText?: string;
+    getDefaultColor(_colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(_colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getPlaceholderColor(): string | undefined;
+    getPadding(): Padding;
+    getText(): {
+        text: string;
+        isPlaceholder: boolean;
+    };
+    getTextInputCoords(context: AnnotationContext, _height: number): {
+        x: number;
+        y: number;
+    };
+    getTextPosition(): AnnotationTextPosition;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/properties/textualStartEndProperties.d.ts

@@ -0,0 +1,45 @@
+import { type AnnotationContext, type AnnotationOptionsColorPickerType, type Padding } from '../annotationTypes';
+import type { AnnotationTextAlignment, AnnotationTextPosition } from '../text/util';
+import { StartEndProperties } from './startEndProperties';
+declare const TextualStartEndProperties_base: {
+    new (...args: any[]): {
+        localeManager?: import("packages/ag-charts-community/dist/types/src/locale/localeManager").LocaleManager | undefined;
+        setLocaleManager(localeManager: import("packages/ag-charts-community/dist/types/src/locale/localeManager").LocaleManager): void;
+    };
+} & {
+    new (...args: any[]): {
+        padding?: number | undefined;
+        textAlign: import("packages/ag-charts-types/dist/types/src/main").TextAlign;
+        formatter?: import("packages/ag-charts-types/dist/types/src/main").Formatter<import("../annotationProperties").AxisLabelFormatterParams> | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        fontStyle?: import("packages/ag-charts-types/dist/types/src/main").FontStyle | undefined;
+        fontWeight?: import("packages/ag-charts-types/dist/types/src/main").FontWeight | undefined;
+        fontSize: number;
+        fontFamily: string;
+        color?: string | undefined;
+    };
+} & typeof StartEndProperties;
+export declare class TextualStartEndProperties extends TextualStartEndProperties_base {
+    text: string;
+    position: AnnotationTextPosition;
+    alignment: AnnotationTextAlignment;
+    placement: 'inside' | 'outside';
+    width?: number;
+    placeholderText?: string;
+    getDefaultColor(_colorPickerType: AnnotationOptionsColorPickerType): string | undefined;
+    getDefaultOpacity(_colorPickerType: AnnotationOptionsColorPickerType): number | undefined;
+    getPlaceholderColor(): string | undefined;
+    getPadding(): Padding;
+    getText(): {
+        text: string;
+        isPlaceholder: boolean;
+    };
+    getTextInputCoords(context: AnnotationContext, _height: number): {
+        x: number;
+        y: number;
+    };
+    getTextPosition(): AnnotationTextPosition;
+}
+export {};

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/scenes/annotationScene.d.ts

@@ -0,0 +1,19 @@
+import { _ModuleSupport } from 'ag-charts-community';
+import { ZIndexMap } from 'ag-charts-core';
+export declare abstract class AnnotationScene extends _ModuleSupport.Group {
+    static isCheck(value: unknown, type: string): boolean;
+    name: string;
+    zIndex: ZIndexMap;
+    abstract type: string;
+    abstract activeHandle?: string;
+    abstract containsPoint(x: number, y: number): boolean;
+    abstract toggleHandles(show: boolean | Record<string, boolean>): void;
+    abstract toggleActive(active: boolean): void;
+    abstract stopDragging(): void;
+    abstract getAnchor(): _ModuleSupport.FloatingToolbarAnchor;
+    abstract getCursor(): string | undefined;
+    abstract getNodeAtCoords(x: number, y: number): string | undefined;
+    toggleHovered(hovered: boolean, active: boolean, readOnly: boolean | undefined): void;
+    protected computeBBoxWithoutHandles(): _ModuleSupport.BBox;
+    protected updateNode<TNode extends _ModuleSupport.Node>(constructor: new () => TNode, node?: TNode, isConfigured?: boolean): TNode | undefined;
+}

node_modules/ag-charts-enterprise/dist/types/src/features/annotations/scenes/annotationShape.d.ts

@@ -0,0 +1,4 @@
+import { _ModuleSupport } from 'ag-charts-community';
+export declare class AnnotationShape extends _ModuleSupport.Marker {
+    isPointInPath(x: number, y: number): boolean;
+}