@itssumitrai/fin-charter 0.2.0

package/dist/api/series-api.d.ts

@@ -0,0 +1,115 @@
+import { Bar, ColumnData, SeriesType, ISeriesPrimitive } from '../core/types';
+import { DataLayer } from '../core/data-layer';
+import { PriceScale } from '../core/price-scale';
+import { SeriesMarker, ChartEvent } from '../core/series-markers';
+import { PriceLine, PriceLineOptions } from '../core/price-line';
+import { SeriesOptionsMap } from './options';
+export type DataChangedCallback = () => void;
+export type VisibilityChangeCallback = (visible: boolean) => void;
+export interface ISeriesApi<T extends SeriesType> {
+    /** Replace all data on this series. */
+    setData(data: Bar[] | ColumnData): void;
+    /** Append or update a single bar (real-time). */
+    update(bar: Bar): void;
+    /** Attach a custom series primitive (plugin). */
+    attachPrimitive(primitive: ISeriesPrimitive): void;
+    /** Detach a previously attached primitive. */
+    detachPrimitive(primitive: ISeriesPrimitive): void;
+    /** Update the series options. */
+    applyOptions(options: Partial<SeriesOptionsMap[T]>): void;
+    /** Return the current series options. */
+    options(): SeriesOptionsMap[T];
+    /** Return the associated price scale. */
+    priceScale(): PriceScale;
+    /** Return the bar at the given index, or null. */
+    dataByIndex(index: number): Bar | null;
+    /** The series type. */
+    seriesType(): T;
+    /** Set markers on this series. */
+    setMarkers(markers: SeriesMarker[]): void;
+    /** Get current markers. */
+    getMarkers(): readonly SeriesMarker[];
+    /** Set chart events on this series. */
+    setEvents(events: ChartEvent[]): void;
+    /** Get current chart events. */
+    getEvents(): readonly ChartEvent[];
+    /** Create a horizontal price line on this series. */
+    createPriceLine(options: PriceLineOptions): PriceLine;
+    /** Remove a price line. */
+    removePriceLine(line: PriceLine): void;
+    /** Get all price lines. */
+    getPriceLines(): readonly PriceLine[];
+    /** Prepend historical bars to the beginning of the series (for pagination). */
+    prependData(data: Bar[] | ColumnData): void;
+    /**
+     * Return metadata about how many bars fall outside the given logical index range.
+     * Useful for deciding when to load more historical data.
+     */
+    barsInLogicalRange(range: {
+        from: number;
+        to: number;
+    }): {
+        barsBefore: number;
+        barsAfter: number;
+        from: number;
+        to: number;
+    };
+    /** Subscribe to data changes (setData / update). */
+    subscribeDataChanged(callback: DataChangedCallback): void;
+    /** Unsubscribe from data changes. */
+    unsubscribeDataChanged(callback: DataChangedCallback): void;
+    /** Subscribe to visibility changes. */
+    subscribeVisibilityChange(callback: VisibilityChangeCallback): void;
+    /** Unsubscribe from visibility changes. */
+    unsubscribeVisibilityChange(callback: VisibilityChangeCallback): void;
+}
+export declare class SeriesApi<T extends SeriesType> implements ISeriesApi<T> {
+    private _type;
+    private _dataLayer;
+    private _priceScale;
+    private _options;
+    private _primitives;
+    private _markers;
+    private _events;
+    private _priceLines;
+    private _requestRepaint;
+    private _visible;
+    private _dataChangedCallbacks;
+    private _visibilityChangeCallbacks;
+    constructor(type: T, dataLayer: DataLayer, priceScale: PriceScale, options: SeriesOptionsMap[T], requestRepaint: () => void);
+    setData(data: Bar[] | ColumnData): void;
+    update(bar: Bar): void;
+    prependData(data: Bar[] | ColumnData): void;
+    barsInLogicalRange(range: {
+        from: number;
+        to: number;
+    }): {
+        barsBefore: number;
+        barsAfter: number;
+        from: number;
+        to: number;
+    };
+    attachPrimitive(primitive: ISeriesPrimitive): void;
+    detachPrimitive(primitive: ISeriesPrimitive): void;
+    applyOptions(options: Partial<SeriesOptionsMap[T]>): void;
+    options(): SeriesOptionsMap[T];
+    priceScale(): PriceScale;
+    dataByIndex(index: number): Bar | null;
+    seriesType(): T;
+    setMarkers(markers: SeriesMarker[]): void;
+    getMarkers(): readonly SeriesMarker[];
+    setEvents(events: ChartEvent[]): void;
+    getEvents(): readonly ChartEvent[];
+    createPriceLine(options: PriceLineOptions): PriceLine;
+    removePriceLine(line: PriceLine): void;
+    getPriceLines(): readonly PriceLine[];
+    subscribeDataChanged(callback: DataChangedCallback): void;
+    unsubscribeDataChanged(callback: DataChangedCallback): void;
+    subscribeVisibilityChange(callback: VisibilityChangeCallback): void;
+    unsubscribeVisibilityChange(callback: VisibilityChangeCallback): void;
+    getDataLayer(): DataLayer;
+    getPrimitives(): readonly ISeriesPrimitive[];
+    isVisible(): boolean;
+    private _notifyPrimitives;
+    private _emitDataChanged;
+}

package/dist/core/accessibility.d.ts

@@ -0,0 +1,90 @@
+export interface BarData {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+/**
+ * ChartAccessibility manages ARIA live regions and focus management for
+ * screen-reader support on financial charts. It provides methods to announce
+ * price changes, OHLCV bar data, and manage keyboard navigation state.
+ */
+export declare class ChartAccessibility {
+    private _container;
+    private _liveRegion;
+    private _description;
+    private _focusedBarIndex;
+    private _totalBars;
+    private _disposed;
+    /**
+     * Create a hidden ARIA live region inside the given container.
+     * The live region is used to announce dynamic content to screen readers.
+     */
+    createAriaLiveRegion(container: HTMLElement): HTMLElement;
+    /**
+     * Announce the current price and change to screen readers.
+     * @param price - The current price value.
+     * @param change - The price change (positive or negative).
+     */
+    announcePrice(price: number, change: number): void;
+    /**
+     * Announce OHLCV bar data to screen readers.
+     * @param bar - The bar data to announce.
+     */
+    announceBar(bar: BarData): void;
+    /**
+     * Set a description on the chart container as aria-label.
+     * @param description - The description text.
+     */
+    setChartDescription(description: string): void;
+    /** Get the current chart description. */
+    getChartDescription(): string;
+    /**
+     * Set the chart container as focusable and focus it.
+     * This enables keyboard navigation on the chart.
+     */
+    focusChart(): void;
+    /**
+     * Set the total number of bars for keyboard navigation.
+     */
+    setTotalBars(count: number): void;
+    /**
+     * Get the currently focused bar index for keyboard navigation.
+     * Returns -1 if no bar is focused.
+     */
+    get focusedBarIndex(): number;
+    /** Get total bars available for navigation. */
+    get totalBars(): number;
+    /**
+     * Move focus to the next bar (right arrow key).
+     * Returns the new focused bar index, or -1 if at the end.
+     */
+    focusNextBar(): number;
+    /**
+     * Move focus to the previous bar (left arrow key).
+     * Returns the new focused bar index, or -1 if at the beginning.
+     */
+    focusPreviousBar(): number;
+    /**
+     * Move focus to the first bar.
+     */
+    focusFirstBar(): number;
+    /**
+     * Move focus to the last bar.
+     */
+    focusLastBar(): number;
+    /**
+     * Reset focused bar index.
+     */
+    resetFocus(): void;
+    /**
+     * Get the ARIA live region element (or null if not created).
+     */
+    get liveRegion(): HTMLElement | null;
+    /**
+     * Clean up: remove the live region from the DOM and reset state.
+     */
+    dispose(): void;
+}

package/dist/core/alert-line.d.ts

@@ -0,0 +1,49 @@
+export type AlertTriggerMode = 'crossing-up' | 'crossing-down' | 'crossing-either';
+export type AlertLineCallback = (alert: AlertLine, direction: 'up' | 'down') => void;
+export interface AlertLineOptions {
+    price: number;
+    color: string;
+    lineWidth: number;
+    lineStyle: 'solid' | 'dashed' | 'dotted';
+    title: string;
+    triggerMode: AlertTriggerMode;
+    /** Whether the alert is armed (will fire callbacks on crossing). */
+    armed: boolean;
+    /** Show a bell icon on the price axis. */
+    axisLabelVisible: boolean;
+    axisLabelColor?: string;
+    axisLabelTextColor?: string;
+}
+export declare const DEFAULT_ALERT_LINE_OPTIONS: AlertLineOptions;
+/**
+ * AlertLine — a price level that fires callbacks when the current price
+ * crosses it. Distinct from PriceLine: alerts have armed/disarmed state,
+ * trigger modes, and can be dragged to adjust the price.
+ */
+export declare class AlertLine {
+    readonly id: string;
+    private _options;
+    private _callbacks;
+    private _lastPrice;
+    private _requestRepaint;
+    constructor(id: string, options: AlertLineOptions, requestRepaint?: () => void);
+    get options(): Readonly<AlertLineOptions>;
+    applyOptions(opts: Partial<AlertLineOptions>): void;
+    /** Subscribe to alert trigger events. */
+    onTriggered(callback: AlertLineCallback): void;
+    /** Unsubscribe from alert trigger events. */
+    offTriggered(callback: AlertLineCallback): void;
+    /** Arm or disarm the alert. */
+    setArmed(armed: boolean): void;
+    isArmed(): boolean;
+    /**
+     * Check if the current price has crossed the alert level since the last
+     * check, and fire callbacks if so. Called by the chart on each data update.
+     */
+    checkCrossing(currentPrice: number): void;
+    /** Serialize to a plain object for chart state save/restore. */
+    serialize(): {
+        id: string;
+        options: AlertLineOptions;
+    };
+}

package/dist/core/chart-state.d.ts

@@ -0,0 +1,39 @@
+import { DeepPartial, SeriesType } from './types';
+import { ChartOptions, IndicatorType } from '../api/options';
+import { Periodicity } from './periodicity';
+import { MarketSession } from './market-session';
+import { SerializedDrawing } from '../drawings/base';
+export declare const CHART_STATE_VERSION = 1;
+export interface ChartState {
+    version: number;
+    options: DeepPartial<ChartOptions>;
+    periodicity?: Periodicity;
+    comparisonMode?: boolean;
+    timeScale: {
+        barSpacing: number;
+        rightOffset: number;
+    };
+    series: Array<{
+        id: string;
+        type: SeriesType;
+        options: Record<string, unknown>;
+    }>;
+    indicators: Array<{
+        type: IndicatorType;
+        sourceSeriesId: string;
+        params: Record<string, number>;
+        color?: string;
+    }>;
+    panes: Array<{
+        id: string;
+        height: number;
+    }>;
+    drawings: SerializedDrawing[];
+    marketSessions?: MarketSession[];
+    sessionFilter?: string;
+    visibleRange?: {
+        from: number;
+        to: number;
+    };
+}
+export declare function validateChartState(state: unknown): state is ChartState;

package/dist/core/chart-sync.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Minimal chart interface required for synchronization.
+ * Compatible with IChartApi but allows lightweight mocking in tests.
+ */
+export interface ISyncableChart {
+    subscribeCrosshairMove(callback: (state: SyncCrosshairState | null) => void): void;
+    unsubscribeCrosshairMove(callback: (state: SyncCrosshairState | null) => void): void;
+    subscribeVisibleRangeChange(callback: (range: {
+        from: number;
+        to: number;
+    } | null) => void): void;
+    unsubscribeVisibleRangeChange(callback: (range: {
+        from: number;
+        to: number;
+    } | null) => void): void;
+    setVisibleRange(from: number, to: number): void;
+}
+export interface SyncCrosshairState {
+    time: number;
+    price: number;
+    x: number;
+    y: number;
+    barIndex: number;
+}
+export type CrosshairSyncCallback = (sourceChart: ISyncableChart, state: SyncCrosshairState | null) => void;
+export type TimeScaleSyncCallback = (sourceChart: ISyncableChart, range: {
+    from: number;
+    to: number;
+}) => void;
+/**
+ * ChartSyncGroup synchronizes multiple chart instances so that crosshair
+ * movement and time-scale panning/zooming on one chart is mirrored to all
+ * others in the group.
+ *
+ * Usage:
+ * ```ts
+ * const group = new ChartSyncGroup();
+ * group.addChart(chart1);
+ * group.addChart(chart2);
+ * group.syncCrosshair();   // enable crosshair sync
+ * group.syncTimeScale();   // enable time-scale sync
+ * // later:
+ * group.dispose();
+ * ```
+ */
+export declare class ChartSyncGroup {
+    private _entries;
+    private _crosshairSyncing;
+    private _timeScaleSyncing;
+    private _disposed;
+    /** Guard flag to prevent re-entrant crosshair sync loops. */
+    private _broadcastingCrosshair;
+    /** Guard flag to prevent re-entrant time-scale sync loops. */
+    private _broadcastingTimeScale;
+    private _crosshairCallbacks;
+    private _timeScaleCallbacks;
+    /** Add a chart to the sync group. */
+    addChart(chart: ISyncableChart): void;
+    /** Remove a chart from the sync group. */
+    removeChart(chart: ISyncableChart): void;
+    /** Enable crosshair synchronization across all charts in the group. */
+    syncCrosshair(): void;
+    /** Enable time-scale synchronization across all charts in the group. */
+    syncTimeScale(): void;
+    /** Subscribe to crosshair sync events for custom handling. */
+    onCrosshairSync(callback: CrosshairSyncCallback): void;
+    /** Unsubscribe from crosshair sync events for custom handling. */
+    offCrosshairSync(callback: CrosshairSyncCallback): void;
+    /** Subscribe to time-scale sync events for custom handling. */
+    onTimeScaleSync(callback: TimeScaleSyncCallback): void;
+    /** Unsubscribe from time-scale sync events for custom handling. */
+    offTimeScaleSync(callback: TimeScaleSyncCallback): void;
+    /** Get the number of charts in the group. */
+    get chartCount(): number;
+    /** Whether crosshair sync is active. */
+    get isCrosshairSyncing(): boolean;
+    /** Whether time-scale sync is active. */
+    get isTimeScaleSyncing(): boolean;
+    /** Tear down all subscriptions and clear charts. */
+    dispose(): void;
+    private _onCrosshairMove;
+    private _onVisibleRangeChange;
+}

package/dist/core/crosshair.d.ts

@@ -0,0 +1,28 @@
+export interface CrosshairState {
+    x: number;
+    y: number;
+    barIndex: number;
+    price: number;
+    time: number;
+    /** X coordinate snapped to the bar centre (optional — falls back to x). */
+    snappedX?: number;
+    /** The pane that generated this crosshair event. */
+    sourcePaneId?: string;
+}
+export declare class Crosshair {
+    visible: boolean;
+    x: number;
+    y: number;
+    barIndex: number;
+    price: number;
+    time: number;
+    /** The ID of the pane the pointer is currently over. */
+    sourcePaneId: string;
+    private _snappedX;
+    /** X coordinate snapped to the bar centre; falls back to x if not provided. */
+    get snappedX(): number;
+    /** Make the crosshair visible and update all properties. */
+    update(state: CrosshairState): void;
+    /** Hide the crosshair. */
+    hide(): void;
+}

package/dist/core/css-theme.d.ts

@@ -0,0 +1,41 @@
+import { DeepPartial } from './types';
+import { ChartOptions } from '../api/options';
+/**
+ * CSS custom property names used by fin-charter.
+ * All prefixed with --fc- to avoid collisions.
+ */
+export declare const CSS_VARS: {
+    readonly bg: "--fc-bg";
+    readonly text: "--fc-text";
+    readonly fontSize: "--fc-font-size";
+    readonly fontFamily: "--fc-font-family";
+    readonly gridHorzColor: "--fc-grid-horz-color";
+    readonly gridVertColor: "--fc-grid-vert-color";
+    readonly crosshairVertColor: "--fc-crosshair-vert-color";
+    readonly crosshairHorzColor: "--fc-crosshair-horz-color";
+    readonly candleUpColor: "--fc-candle-up";
+    readonly candleDownColor: "--fc-candle-down";
+    readonly lineColor: "--fc-line-color";
+    readonly areaTopColor: "--fc-area-top";
+    readonly areaBottomColor: "--fc-area-bottom";
+    readonly areaLineColor: "--fc-area-line";
+    readonly volumeUpColor: "--fc-volume-up";
+    readonly volumeDownColor: "--fc-volume-down";
+    readonly watermarkColor: "--fc-watermark-color";
+};
+/**
+ * Read CSS custom properties from a container element and return
+ * a partial ChartOptions object. Undefined properties (not set in CSS)
+ * are omitted so mergeOptions will skip them.
+ */
+export declare function readCSSTheme(container: HTMLElement): DeepPartial<ChartOptions>;
+/**
+ * Generate a CSS string that sets all custom properties for a theme.
+ * Can be applied to a container element via `element.style.cssText` or
+ * inserted into a <style> block.
+ */
+export declare function generateCSSTheme(options: DeepPartial<ChartOptions>): string;
+/**
+ * Apply CSS custom properties for a theme directly to an element.
+ */
+export declare function applyCSSTheme(element: HTMLElement, options: DeepPartial<ChartOptions>): void;

package/dist/core/custom-indicator.d.ts

@@ -0,0 +1,70 @@
+import { ColumnStore } from './types';
+/**
+ * Output descriptor for a custom indicator output line.
+ */
+export interface IndicatorOutput {
+    /** Name of this output (e.g., 'upper', 'middle', 'lower'). */
+    name: string;
+    /** Default color for rendering. */
+    color?: string;
+    /** Rendering style: 'line' (default), 'histogram', 'dots', 'area'. */
+    style?: 'line' | 'histogram' | 'dots' | 'area';
+}
+/**
+ * Parameter descriptor for a custom indicator parameter.
+ */
+export interface IndicatorParam {
+    /** Parameter name. */
+    name: string;
+    /** Default value. */
+    defaultValue: number;
+    /** Minimum value (for UI validation). */
+    min?: number;
+    /** Maximum value (for UI validation). */
+    max?: number;
+    /** Step for UI controls. */
+    step?: number;
+}
+/**
+ * Compute function signature for custom indicators.
+ * Receives the ColumnStore and parameter values, returns a map of output name → Float64Array.
+ */
+export type IndicatorComputeFn = (store: ColumnStore, params: Record<string, number>) => Map<string, Float64Array>;
+/**
+ * Descriptor for registering a custom indicator.
+ */
+export interface CustomIndicatorDescriptor {
+    /** Unique name for this indicator type. */
+    name: string;
+    /** Human-readable label for UI. */
+    label: string;
+    /** Whether this indicator overlays on the main price chart or gets its own pane. */
+    overlay: boolean;
+    /** Parameter definitions with defaults. */
+    params: IndicatorParam[];
+    /** Output definitions (multiple outputs supported, e.g., MACD has signal + histogram). */
+    outputs: IndicatorOutput[];
+    /** Compute function that produces output values from bar data and parameters. */
+    compute: IndicatorComputeFn;
+}
+/**
+ * Registry for custom indicator types.
+ * Indicators registered here appear alongside built-in indicators.
+ */
+export declare class CustomIndicatorRegistry {
+    private _descriptors;
+    /** Register a custom indicator type. */
+    register(descriptor: CustomIndicatorDescriptor): void;
+    /** Unregister a custom indicator type. */
+    unregister(name: string): boolean;
+    /** Get a registered descriptor by name. */
+    get(name: string): CustomIndicatorDescriptor | undefined;
+    /** List all registered custom indicator names. */
+    list(): string[];
+    /** Check if a custom indicator type is registered. */
+    has(name: string): boolean;
+    /** Get all registered descriptors. */
+    getAll(): CustomIndicatorDescriptor[];
+    /** Compute a custom indicator's outputs for the given data and params. */
+    compute(name: string, store: ColumnStore, params: Record<string, number>): Map<string, Float64Array>;
+}

package/dist/core/data-feed.d.ts

@@ -0,0 +1,59 @@
+import { Bar } from './types';
+/**
+ * IDataFeed — abstraction for fetching OHLCV bar data with pagination.
+ *
+ * Implementations provide a `getBars()` method that the chart calls when
+ * the user scrolls to the edge and more historical data is needed.
+ */
+export interface IDataFeed {
+    /**
+     * Fetch bars for the given symbol and resolution within the time range.
+     * @param symbol - Symbol identifier (e.g., 'AAPL', 'BTCUSD')
+     * @param resolution - Bar interval (e.g., '1', '5', '15', '60', 'D', 'W')
+     * @param from - Start of range (Unix timestamp, seconds)
+     * @param to - End of range (Unix timestamp, seconds)
+     * @returns Promise resolving to an array of bars, sorted by time ascending.
+     *          Empty array means no more data available for the requested range.
+     */
+    getBars(symbol: string, resolution: string, from: number, to: number): Promise<Bar[]>;
+}
+export interface DataFeedManagerOptions {
+    /** Maximum number of cached range entries per symbol+resolution (default: 100). */
+    maxCacheEntries?: number;
+}
+/**
+ * DataFeedManager wraps an IDataFeed with:
+ * - Request deduplication (won't re-fetch the same range)
+ * - Local cache with configurable size limit
+ * - Gap detection for missing ranges
+ * - Loading state tracking
+ */
+export declare class DataFeedManager {
+    private _feed;
+    private _cache;
+    private _pendingRequests;
+    private _loading;
+    private _maxCacheEntries;
+    constructor(feed: IDataFeed, options?: DataFeedManagerOptions);
+    /** Whether a fetch is currently in progress. */
+    get loading(): boolean;
+    /**
+     * Fetch bars with deduplication and caching.
+     * If the requested range (or a superset) is already cached, returns cached data.
+     * Otherwise fetches from the underlying data feed and caches the result.
+     */
+    getBars(symbol: string, resolution: string, from: number, to: number): Promise<Bar[]>;
+    /**
+     * Detect gaps in cached data and return the missing ranges that need fetching.
+     */
+    findGaps(symbol: string, resolution: string, from: number, to: number): Array<{
+        from: number;
+        to: number;
+    }>;
+    /** Clear the cache for a specific symbol+resolution, or all if not specified. */
+    clearCache(symbol?: string, resolution?: string): void;
+    /** Get the number of cached entries for a symbol+resolution. */
+    cacheSize(symbol: string, resolution: string): number;
+    private _findCachedBars;
+    private _addToCache;
+}

package/dist/core/data-layer.d.ts

@@ -0,0 +1,38 @@
+import { Bar, ColumnData, ColumnStore } from './types';
+import { MinMaxSegmentTree } from './segment-tree';
+export declare class DataLayer {
+    store: ColumnStore;
+    readonly segmentTree: MinMaxSegmentTree;
+    constructor();
+    /** Load data. Accepts either an array of Bar objects or a ColumnData (typed arrays). */
+    setData(data: Bar[] | ColumnData): void;
+    /**
+     * Upsert a single bar:
+     * - If the timestamp matches the last bar, overwrite in-place.
+     * - Otherwise append (growing the store if needed).
+     */
+    update(bar: Bar): void;
+    /**
+     * Binary search for the index whose time is closest to `time`.
+     * Result is clamped to [0, length-1].
+     */
+    findIndex(time: number): number;
+    /** Return the Bar at `index`, or null if out of bounds. */
+    barAt(index: number): Bar | null;
+    /**
+     * Prepend bars to the beginning of the store.
+     * Accepts either an array of Bar objects or a ColumnData (typed arrays).
+     * The prepended data must be strictly older than the existing data.
+     */
+    prepend(data: Bar[] | ColumnData): void;
+    /**
+     * Query the min low and max high in the range [fromIdx, toIdx] (inclusive).
+     * O(log n) time via segment tree.
+     */
+    queryMinMax(fromIdx: number, toIdx: number): {
+        min: number;
+        max: number;
+    };
+    /** Double the capacity of the store, preserving existing data. */
+    private grow;
+}

package/dist/core/invalidation.d.ts

@@ -0,0 +1,24 @@
+import { InvalidationLevelValue } from './types';
+export declare class InvalidateMask {
+    /** Map from pane id → highest invalidation level for that pane. */
+    private _levels;
+    /** Register a pane (starts at None). */
+    addPane(id: string): void;
+    /** Remove a pane from tracking. */
+    removePane(id: string): void;
+    /**
+     * Set the invalidation level for a pane.
+     * Keeps whichever value is higher (existing vs. requested).
+     */
+    invalidate(paneId: string, level: InvalidationLevelValue): void;
+    /** Apply `level` to every tracked pane. */
+    invalidateAll(level: InvalidationLevelValue): void;
+    /** Return the current invalidation level for a pane. */
+    level(paneId: string): InvalidationLevelValue;
+    /** True if at least one pane has a level above None. */
+    needsRepaint(): boolean;
+    /** Return all tracked pane ids. */
+    paneIds(): string[];
+    /** Reset all pane levels back to None. */
+    reset(): void;
+}

package/dist/core/market-session.d.ts

@@ -0,0 +1,11 @@
+export interface MarketSession {
+    id: string;
+    label: string;
+    startMinute: number;
+    endMinute: number;
+    bgColor: string;
+}
+export declare const US_EQUITY_SESSIONS: MarketSession[];
+export declare function isInSession(minuteOfDay: number, session: MarketSession): boolean;
+export declare function getSessionForTime(minuteOfDay: number, sessions: MarketSession[]): MarketSession | null;
+export declare function timestampToMinuteOfDay(timestamp: number, utcOffsetOrTimezone?: number | string): number;