tsichart-core 1.0.5 → 2.0.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,1744 @@
+import * as d3 from 'd3';
+
+declare enum YAxisStates {
+    Stacked = "stacked",
+    Shared = "shared",
+    Overlap = "overlap"
+}
+declare enum TooltipMeasureFormat {
+    Enveloped = "Enveloped",
+    SingleValue = "SingleValue",
+    Scatter = "Scatter"
+}
+
+declare class Strings {
+    private stringValueDefaults;
+    private stringValues;
+    constructor();
+    mergeStrings(stringKeyValues: any): void;
+    getString(stringKey: string): any;
+    toObject(): any;
+}
+
+interface HorizontalMarker {
+    color: string;
+    value: number;
+}
+
+interface swimLaneOption {
+    yAxisType: YAxisStates;
+    label?: string;
+    onClick?: (lane: number) => any;
+    collapseEvents?: string;
+    horizontalMarkers?: Array<HorizontalMarker>;
+}
+declare class ChartOptions {
+    aggTopMargin: number;
+    arcWidthRatio: number;
+    autoTriggerBrushContextMenu: boolean;
+    availabilityLeftMargin: number;
+    bucketSizeMillis: number;
+    brushClearable: boolean;
+    brushContextMenuActions: Array<any>;
+    brushHandlesVisible: boolean;
+    brushMoveAction: any;
+    brushMoveEndAction: any;
+    brushRangeVisible: boolean;
+    canDownload: boolean;
+    color: string;
+    colors: Array<string>;
+    dateLocale: string;
+    defaultAvailabilityZoomRangeMillis: number;
+    defaultColor: any;
+    dTPIsModal: boolean;
+    ellipsisItems: Array<any>;
+    focusHidden: boolean;
+    fromChart: boolean;
+    grid: boolean;
+    hideChartControlPanel: boolean;
+    includeDots: boolean;
+    includeEnvelope: boolean;
+    includeTimezones: boolean;
+    initialValue: any;
+    interpolationFunction: any;
+    isArea: boolean;
+    isColorValueHidden: boolean;
+    isCompact: boolean;
+    isTemporal: boolean;
+    is24HourTime: boolean;
+    keepBrush: boolean;
+    keepSplitByColor: boolean;
+    labelSeriesWithMarker: boolean;
+    legend: string;
+    markers: Array<any>;
+    maxBuckets: number;
+    minBrushWidth: number;
+    minutesForTimeLabels: boolean;
+    noAnimate: boolean;
+    numberOfColors: number;
+    updateInterval: number;
+    offset: any;
+    isRelative: any;
+    currentQuickTime: any;
+    onClick: (d3Event: any) => void;
+    onInput: (searchText: string, event: any) => void;
+    onInstanceClick: (instance: any) => any;
+    onKeydown: (d3Event: any, awesompleteObject: any) => void;
+    onMarkersChange: (markers: Array<number>) => any;
+    onMouseout: () => void;
+    onMouseover: (aggKey: string, splitBy: string) => void;
+    onSelect: (value: any) => void;
+    onSticky: (aggKey: string, splitBy: string) => void;
+    onUnsticky: (aggKey: string, splitBy: string) => void;
+    preserveAvailabilityState: boolean;
+    persistDateTimeButtonRange: boolean;
+    scaledToCurrentTime: boolean;
+    spMeasures: Array<string>;
+    scatterPlotRadius: Array<number>;
+    spAxisLabels: Array<string>;
+    singleLineXAxisLabel: boolean;
+    snapBrush: boolean;
+    stacked: boolean;
+    shouldSticky: boolean;
+    strings: any;
+    suppressResizeListener: boolean;
+    swimLaneOptions: {
+        [key: number]: swimLaneOption;
+    } | null;
+    theme: string;
+    timeFrame: any;
+    timestamp: any;
+    tooltip: boolean;
+    throttleSlider: boolean;
+    warmStoreRange: Array<string>;
+    xAxisHidden: boolean;
+    xAxisTimeFormat: (d: any, i: any, isFirst: any, isLast: any) => {};
+    yAxisHidden: boolean;
+    yAxisState: string;
+    yExtent: any;
+    zeroYAxis: boolean;
+    withContextMenu: boolean;
+    hierarchyOptions: any;
+    onError: (titleKey: any, messageKey: any, xhr: any) => any;
+    timeSeriesIdProperties: Array<{
+        name: string;
+        type: any;
+    }>;
+    stringsInstance: Strings;
+    private getInterpolationFunction;
+    setOptions(chartOptionsObj: any): void;
+    private mergeStrings;
+    private mergeValue;
+    toObject(): {
+        grid: boolean;
+        preserveAvailabilityState: boolean;
+        persistDateTimeButtonRange: boolean;
+        isCompact: boolean;
+        keepBrush: boolean;
+        isArea: boolean;
+        noAnimate: boolean;
+        minutesForTimeLabels: boolean;
+        aggTopMargin: number;
+        color: string;
+        maxBuckets: number;
+        yAxisHidden: boolean;
+        focusHidden: boolean;
+        singleLineXAxisLabel: boolean;
+        legend: string;
+        tooltip: boolean;
+        throttleSlider: boolean;
+        snapBrush: boolean;
+        minBrushWidth: number;
+        theme: string;
+        keepSplitByColor: boolean;
+        brushContextMenuActions: any[];
+        timeFrame: any;
+        fromChart: boolean;
+        timestamp: any;
+        stacked: boolean;
+        scaledToCurrentTime: boolean;
+        zeroYAxis: boolean;
+        arcWidthRatio: number;
+        brushClearable: boolean;
+        brushMoveAction: any;
+        yAxisState: string;
+        xAxisHidden: boolean;
+        suppressResizeListener: boolean;
+        brushMoveEndAction: any;
+        onMouseout: () => void;
+        onMouseover: (aggKey: string, splitBy: string) => void;
+        onSticky: (aggKey: string, splitBy: string) => void;
+        onUnsticky: (aggKey: string, splitBy: string) => void;
+        onKeydown: (d3Event: any, awesompleteObject: any) => void;
+        onInput: (searchText: string, event: any) => void;
+        brushHandlesVisible: boolean;
+        hideChartControlPanel: boolean;
+        offset: any;
+        is24HourTime: () => boolean;
+        includeTimezones: boolean;
+        availabilityLeftMargin: number;
+        onInstanceClick: (instance: any) => any;
+        interpolationFunction: any;
+        includeEnvelope: boolean;
+        canDownload: boolean;
+        withContextMenu: boolean;
+        autoTriggerBrushContextMenu: boolean;
+        includeDots: boolean;
+        yExtent: any;
+        ellipsisItems: any[];
+        markers: any[];
+        onMarkersChange: (markers: Array<number>) => any;
+        xAxisTimeFormat: (d: any, i: any, isFirst: any, isLast: any) => {};
+        spMeasures: string[];
+        scatterPlotRadius: number[];
+        spAxisLabels: string[];
+        brushRangeVisible: boolean;
+        strings: any;
+        dateLocale: string;
+        defaultAvailabilityZoomRangeMillis: number;
+        warmStoreRange: string[];
+        initialValue: any;
+        bucketSizeMillis: number;
+        updateInterval: number;
+        dTPIsModal: boolean;
+        numberOfColors: number;
+        defaultColor: any;
+        isColorValueHidden: boolean;
+        onClick: (d3Event: any) => void;
+        onSelect: (value: any) => void;
+        colors: string[];
+        swimLaneOptions: {
+            [key: number]: swimLaneOption;
+        };
+        hierarchyOptions: any;
+        onError: (titleKey: any, messageKey: any, xhr: any) => any;
+        labelSeriesWithMarker: boolean;
+        timeSeriesIdProperties: {
+            name: string;
+            type: any;
+        }[];
+        shouldSticky: boolean;
+        isRelative: any;
+        currentQuickTime: any;
+    };
+}
+
+declare class Component {
+    renderTarget: any;
+    protected currentTheme: string;
+    readonly TRANSDURATION: number;
+    usesSeconds: boolean;
+    usesMillis: boolean;
+    protected chartOptions: ChartOptions;
+    protected getString(str: string): any;
+    constructor(renderTarget: Element);
+    protected themify(targetElement: any, theme: string): void;
+    protected teardropD: (width: any, height: any) => string;
+    protected tooltipFormat(d: any, text: any, measureFormat: TooltipMeasureFormat, xyrMeasures?: any): void;
+    protected createTooltipSeriesInfo(d: any, group: any, cDO: any): void;
+}
+
+declare class ChartComponentData {
+    data: any;
+    displayState: any;
+    timeArrays: any;
+    visibleTSCount: number;
+    visibleTAs: any;
+    allValues: any;
+    allNumericValues: any;
+    filteredAggregates: any;
+    usesSeconds: boolean;
+    usesMillis: boolean;
+    fromMillis: number;
+    toMillis: number;
+    stickiedKey: any;
+    allTimestampsArray: any;
+    isFromHeatmap: boolean;
+    constructor();
+    protected getSwimlane: (aggKey: any) => any;
+    protected setAllTimestampsArray(): void;
+    getDataType(aggKey: any): any;
+    private fillColors;
+    private getVisibleType;
+    mergeDataToDisplayStateAndTimeArrays(data: any, aggregateExpressionOptions?: any): void;
+    private determineMeasureTypes;
+    getTemporalShiftStringTuple(aggKey: any): any[];
+    getTemporalShiftMillis(aggKey: any): number;
+    doesTimeArrayUseSeconds(timeArray: any): any;
+    doesTimeArrayUseMillis(timeArray: any): any;
+    setAllValuesAndVisibleTAs(): Date[];
+    findLastTimestampWithValue(aggKey: any, splitBy: any): any;
+    private findFirstBucket;
+    private getNumberOfPaddedBuckets;
+    convertAggregateToArray(agg: any, aggKey: string, aggName: string, splitBy: string, from: Date, to: Date, bucketSize: number, shiftValue: number): Array<any>;
+    isSplitByVisible(aggI: string, splitBy: string): any;
+    isPossibleEnvelope(aggKey: string, splitBy: string): boolean;
+    getVisibleMeasure(aggI: string, splitBy: string): any;
+    getAggVisible(aggKey: any): boolean;
+    getSplitByVisible(aggKey: any, splitBy: any): any;
+    aggHasVisibleSplitBys(aggKey: any): boolean;
+    valueAtTS(aggKey: any, splitByName: any, ts: any): any;
+    setFilteredAggregates(): void;
+    private guessValueType;
+    generateCSVString(offset?: number, dateLocale?: string, spMeasures?: any): string;
+    getVisibilityState(): any[];
+}
+
+declare class EllipsisMenu extends Component {
+    private containerElement;
+    private buttonElement;
+    private menuElement;
+    private menuItems;
+    private menuIsVisible;
+    constructor(renderTarget: Element);
+    private createIconPath;
+    setMenuVisibility(isVisible: any): void;
+    private focusOnMenuItem;
+    private menuItemKeyHandler;
+    render(menuItems: any, options?: any): void;
+    private setMenuItems;
+}
+
+declare class Legend extends Component {
+    drawChart: any;
+    legendElement: any;
+    legendWidth: number;
+    private legendState;
+    private stickySeriesAction;
+    private labelMouseover;
+    private labelMouseout;
+    private svgSelection;
+    private chartComponentData;
+    constructor(drawChart: any, renderTarget: Element, legendWidth: number);
+    private labelMouseoutWrapper;
+    private toggleSplitByVisible;
+    triggerSplitByFocus(aggKey: string, splitBy: string): void;
+    private getHeightPerSplitBy;
+    private createGradient;
+    private isNonNumeric;
+    private createNonNumericColorKey;
+    private createCategoricalColorKey;
+    private createEventsColorKey;
+    private renderSplitBys;
+    private toggleSticky;
+    draw(legendState: string, chartComponentData: any, labelMouseover: any, svgSelection: any, options: any, labelMouseoutAction?: any, stickySeriesAction?: any, event?: any): void;
+}
+
+declare class ChartComponent extends Component {
+    readonly MINWIDTH = 350;
+    protected MINHEIGHT: number;
+    readonly CONTROLSWIDTH = 200;
+    readonly GUTTERWIDTH = 6;
+    data: any;
+    aggregateExpressionOptions: any;
+    protected chartControlsPanel: any;
+    protected ellipsisContainer: any;
+    protected ellipsisMenu: EllipsisMenu;
+    protected legendObject: Legend;
+    protected width: number;
+    protected chartWidth: number;
+    protected svgSelection: any;
+    protected legendWidth: number;
+    draw: any;
+    chartComponentData: ChartComponentData;
+    chartMargins: any;
+    constructor(renderTarget: Element);
+    showGrid(): void;
+    gatedShowGrid(): void;
+    hideGrid(): void;
+    isGridVisible(): boolean;
+    protected drawEllipsisMenu(additionalEllipsisItems?: any[]): void;
+    downloadAsCSV: (isScatterPlot?: boolean) => void;
+    protected removeControlPanel(): void;
+    protected removeEllipsisMenu(): void;
+    protected getWidth(): number;
+    getVisibilityState(): any[];
+    protected ellipsisItemsExist(): boolean;
+    protected getDataType(aggKey: any): any;
+    protected getCDOFromAggKey(aggKey: any): any;
+    protected getFilteredMeasures(measureList: any, visibleMeasure: any, measureFormat: TooltipMeasureFormat, xyrMeasures?: any): any;
+    protected convertToTimeValueFormat(d: any): {
+        aggregateKey: any;
+        splitBy: any;
+        aggregateName: any;
+        measures: {};
+    };
+    protected formatDate(date: any, shiftMillis: any): string;
+    protected tooltipFormat(d: any, text: any, measureFormat: TooltipMeasureFormat, xyrMeasures?: any): void;
+    protected getSVGWidth(): any;
+    protected getChartWidth(legendWidth?: number): number;
+    protected calcSVGWidth(): any;
+    protected setControlsPanelWidth(): void;
+    protected legendPostRenderProcess(legendState: string, chartElement: any, shouldSetControlsWidth: boolean, splitLegendOnDrag?: any): void;
+    protected splitLegendAndSVG(chartElement: any, onDrag?: () => void): void;
+}
+
+declare class ChartVisualizationComponent extends ChartComponent {
+    constructor(renderTarget: Element);
+    render(data: any, options: any, aggregateExpressionOptions: any): void;
+}
+
+declare class TemporalXAxisComponent extends ChartVisualizationComponent {
+    protected xAxis: any;
+    protected x: any;
+    protected chartHeight: any;
+    private smartTickFormat;
+    private xAxisEntered;
+    constructor(renderTarget: Element);
+    private createOffsetXAxis;
+    private createXAxis;
+    private getXTickNumber;
+    private labelFormatUsesSeconds;
+    private labelFormatUsesMillis;
+    updateXAxis(forceFirst?: boolean, forceLast?: boolean): void;
+    private updateAxisText;
+    protected drawXAxis(yOffset: any, snapFirst?: boolean, snapLast?: boolean): void;
+    private isSameDate;
+    private isTickSpanGreaterThan;
+    private createSmartTickFormat;
+}
+
+declare class LineChartData extends ChartComponentData {
+    timeMap: any;
+    get yExtents(): Array<any>;
+    private _yExtents;
+    setYExtents(idx: number, value: [number, number]): void;
+    resetYExtents(): void;
+    setTimeMap(): void;
+    constructor();
+    mergeDataToDisplayStateAndTimeArrays(data: any, aggregateExpressionOptions?: any): void;
+}
+
+declare class LineChart extends TemporalXAxisComponent {
+    private targetElement;
+    private focus;
+    private horizontalValueBox;
+    private verticalValueBox;
+    private horizontalValueBar;
+    private contextMenu;
+    private brushContextMenu;
+    private setDisplayStateFromData;
+    private minBrushWidth;
+    private strokeOpacity;
+    private nonFocusStrokeOpactiy;
+    chartComponentData: LineChartData;
+    private surpressBrushTimeSet;
+    private hasStackedButton;
+    private stackedButton;
+    private visibleAggCount;
+    private swimLaneLabelGroup;
+    private horizontalLabelOffset;
+    private tooltip;
+    private height;
+    private xLowerBound;
+    private xUpperBound;
+    private y;
+    private yMap;
+    private line;
+    private areaPath;
+    private envelope;
+    private voronoi;
+    private possibleTimesArray;
+    private colorMap;
+    private markers;
+    private seriesLabelsMarker;
+    private markerGuidMap;
+    private isDroppingMarker;
+    private activeMarker;
+    private brush;
+    private brushElem;
+    brushStartTime: Date;
+    brushEndTime: Date;
+    private brushStartPosition;
+    private brushEndPosition;
+    private hasBrush;
+    private isClearingBrush;
+    private previousAggregateData;
+    private previousIncludeDots;
+    private voronoiDiagram;
+    private voronoiRegion;
+    private mx;
+    private my;
+    private focusedAggKey;
+    private focusedSplitby;
+    private plotComponents;
+    private isFirstMarkerDrop;
+    private xOffset;
+    private swimlaneYExtents;
+    private swimLaneContents;
+    private originalSwimLanes;
+    private originalSwimLaneOptions;
+    constructor(renderTarget: Element);
+    LineChart(): void;
+    getBrushPositions(): {
+        leftPos: any;
+        rightPos: any;
+    };
+    private resetValueElementsFocus;
+    private hideFocusElements;
+    private voronoiMouseout;
+    private createMarkerInstructions;
+    private destroyMarkerInstructions;
+    triggerLineFocus: (aggKey: string, splitBy: string) => void;
+    private getMouseoverFunction;
+    private getMouseoutFunction;
+    private focusOnlyHoveredSeries;
+    private discreteEventsMouseover;
+    private discreteEventsMouseout;
+    private mismatchingChartType;
+    private categoricalMouseover;
+    private categoricalMouseout;
+    private setHorizontalValuePosAndText;
+    private setVerticalValueAndPosition;
+    private voronoiMouseover;
+    private getYExtent;
+    private getFilteredValues;
+    private getFilteredAndSticky;
+    stickyOrUnstickySeries: (aggKey: any, splitBy: any) => void;
+    unstickySeries: (aggKey: any, splitby?: any) => void;
+    private stickySeries;
+    private getHandleHeight;
+    private getXPosition;
+    setBrushStartTime(startTime: any): void;
+    setBrushEndTime(endTime: any): void;
+    setBrush(): void;
+    private findClosestValidTime;
+    private getMarkerMarginLeft;
+    exportMarkers(): void;
+    private createOnMarkerChange;
+    private renderMarker;
+    private sortMarkers;
+    private getAllLinesTransitionsComplete;
+    private importMarkers;
+    private createSeriesLabelsMarker;
+    private renderSeriesLabelsMarker;
+    private renderAllMarkers;
+    private focusOnEllipsis;
+    private filteredValueExist;
+    addMarker: () => void;
+    private voronoiExists;
+    private voronoiMousemove;
+    private voronoiContextMenu;
+    private voronoiClick;
+    private getValueOfVisible;
+    private brushBrush;
+    private brushEnd;
+    private focusMarkerLabel;
+    labelMouseout: () => void;
+    labelMouseover: (aggregateKey: string, splitBy?: string) => void;
+    private drawBrushRange;
+    private getSVGLeftOffset;
+    updateBrushRange(): void;
+    deleteBrushRange(): void;
+    getYExtents(): any[];
+    private nextStackedState;
+    private clearBrush;
+    private getVisibleNumerics;
+    private getSwimlaneOffsets;
+    private setSwimLaneYExtents;
+    private getEventsCollapsedSwimlaneHeight;
+    private createYOffsets;
+    private heightNonNumeric;
+    private getGroupYExtent;
+    private getAggAxisType;
+    private adjustSwimLanes;
+    private overwriteSwimLanes;
+    private getHorizontalMarkersWithYScales;
+    private getAdditionalOffsetFromHorizontalMargin;
+    private drawHorizontalMarkers;
+    private createSwimlaneLabels;
+    render(data: any, options: any, aggregateExpressionOptions: any): void;
+    private createPlot;
+}
+
+declare class AvailabilityChart extends ChartComponent {
+    private fromMillis;
+    private toMillis;
+    private selectedFromMillis;
+    private selectedToMillis;
+    private zoomedFromMillis;
+    private zoomedToMillis;
+    private minBrushWidth;
+    private color;
+    private transformedAvailability;
+    private minGhostWidth;
+    private timeContainer;
+    private dateTimeButton;
+    private margins;
+    private targetElement;
+    private brushMoveAction;
+    private brushContextMenuActions;
+    private timePickerLineChart;
+    private timePickerContainer;
+    private timePickerChart;
+    private timePickerTextContainer;
+    private sparkLineChart;
+    private ae;
+    private rawAvailability;
+    private maxBuckets;
+    private bucketSize;
+    private dateTimePickerContainer;
+    private dateTimePicker;
+    constructor(renderTarget: Element);
+    private getMinZoomedRange;
+    private zoom;
+    private setChartOptions;
+    private dateTimePickerAction;
+    private createDisplayBuckets;
+    private setRangeVariables;
+    render(transformedAvailability: any, chartOptions: any, rawAvailability?: any): void;
+    private buildZoomButtons;
+    private setSelectedMillis;
+    private renderDateTimeButton;
+    private setFromAndToTimes;
+    private drawGhost;
+    private drawWarmRange;
+    private buildCompactFromAndTo;
+    private offsetUTC;
+    private buildFromAndToContainer;
+    private setTicks;
+    private setAvailabilityRange;
+    setBrush(fromMillis: any, toMillis: any, isFromButton?: boolean): void;
+    private createSparkLineOptions;
+}
+
+declare class GroupedBarChartData extends ChartComponentData {
+    timestamp: any;
+    valuesAtTimestamp: any;
+    valuesOfVisibleType: Array<any>;
+    aggsSeries: any;
+    globalMax: number;
+    globalMin: number;
+    stackedAggregateObject: any;
+    constructor();
+    mergeDataToDisplayStateAndTimeArrays(data: any, timestamp: any, aggregateExpressionOptions?: any): void;
+    private stackMin;
+    private stackMax;
+    setEntireRangeData(scaledToCurrentTime: any): void;
+    setValuesAtTimestamp(): void;
+    getValueContainerData(aggKey: any): Array<any>;
+}
+
+declare class PieChartData extends GroupedBarChartData {
+    flatValueArray: any;
+    visibleValuesSum: number;
+    constructor();
+    mergeDataToDisplayStateAndTimeArrays(data: any, timestamp: any, aggregateExpressionOptions?: any): void;
+    updateFlatValueArray(timestamp: any): void;
+}
+
+declare class PieChart extends ChartVisualizationComponent {
+    private contextMenu;
+    chartComponentData: PieChartData;
+    constructor(renderTarget: Element);
+    PieChart(): void;
+    render(data: any, options: any, aggregateExpressionOptions: any): void;
+}
+
+declare class ScatterPlotData extends GroupedBarChartData {
+    temporalDataArray: any;
+    extents: any;
+    private extentsSet;
+    constructor();
+    /******** SETS EXTENT OF EACH DATA MEASURE -- MEASURES UPDATED WHEN RENDER CALLED OUTSIDE OF TEMPORAL ********/
+    setExtents(measures: any, forceReset?: boolean): void;
+    /******** UPDATE EXTENTS BASED ON VISIBLE DATA ********/
+    updateExtents(measures: any): void;
+    /******** UPDATES CHART DATA, ALL TIMESTAMPS, AND VALUES AT THE CURRENT TIMESTAMP ********/
+    mergeDataToDisplayStateAndTimeArrays(data: any, timestamp: any, aggregateExpressionOptions?: any): void;
+    /******** UPDATES DATA TO BE DRAWN -- IF SCATTER IS TEMPORAL, FLATTENS ALL TIMESTAMP DATA ********/
+    updateTemporalDataArray(isTemporal: boolean): void;
+    /******** HELPER TO FETCH DATA AT THE CURRENT TIMESTAMP AND BUILD AN OBJECT FOR THAT TIMESTAMP ********/
+    private updateTemporal;
+    /******** OVERRIDES GROUPEDBARCHARTDATA -- UPDATES VALUES AT TIMESTAMP WITH MEASURES & TIMESTAMP********/
+    setValuesAtTimestamp(): void;
+}
+
+declare class ScatterPlot extends ChartVisualizationComponent {
+    private activeDot;
+    private chartHeight;
+    private controlsOffset;
+    private focus;
+    private focusedAggKey;
+    private focusedSplitBy;
+    private focusedSite;
+    private g;
+    private height;
+    private measures;
+    private pointWrapper;
+    private lineWrapper;
+    private rMeasure;
+    private rScale;
+    private slider;
+    private sliderWrapper;
+    private targetElement;
+    private tooltip;
+    private voronoi;
+    private voronoiDiagram;
+    private voronoiGroup;
+    private xAxis;
+    private xMeasure;
+    private xScale;
+    private yAxis;
+    private yMeasure;
+    private yScale;
+    private xAxisLabel;
+    private yAxisLabel;
+    readonly lowOpacity = 0.15;
+    readonly standardOpacity = 0.6;
+    private focusOpacity;
+    readonly standardStroke = 1;
+    readonly lowStroke = 0.3;
+    chartComponentData: ScatterPlotData;
+    constructor(renderTarget: Element);
+    ScatterPlot(): void;
+    render(data: any, options: any, aggregateExpressionOptions: any, fromSlider?: boolean): void;
+    private getSliderWidth;
+    protected tooltipFormat(d: any, text: any, measureFormat: TooltipMeasureFormat, xyrMeasures: any): void;
+    /******** DRAW UPDATE FUNCTION ********/
+    draw: (isFromResize?: boolean, event?: any) => void;
+    /******** DRAW CONNECTING LINES BETWEEN POINTS ********/
+    private drawConnectingLines;
+    /******** CHECK VALIDITY OF EXTENTS ********/
+    private checkExtentValidity;
+    /******** CREATE VORONOI DIAGRAM FOR MOUSE EVENTS ********/
+    private drawVoronoi;
+    /******** STICKY/UNSTICKY DATA GROUPS ON VORONOI DIAGRAM CLICK ********/
+    private voronoiClick;
+    /******** UPDATE STICKY SPLITBY  ********/
+    stickySeries: (aggregateKey: string, splitBy?: string) => void;
+    /******** HIGHLIGHT DOT TARGETED BY CROSSHAIRS WITH BLACK / WHITE STROKE BORDER ********/
+    private highlightDot;
+    /******** GET UNIQUE STRING HASH ID FOR EACH DOT USING DATA ATTRIBUTES ********/
+    private getClassHash;
+    /******** UNHIGHLIGHT ACTIVE DOT ********/
+    private unhighlightDot;
+    /******** EFFICIENTLY SWAP NEW FOCUSED GROUP WITH OLD FOCUSED GROUP ********/
+    private labelMouseMove;
+    /******** DRAW CROSSHAIRS, TOOLTIP, AND LEGEND FOCUS ********/
+    private voronoiMouseMove;
+    /******** HIDE TOOLTIP AND CROSSHAIRS ********/
+    private voronoiMouseOut;
+    /******** FILTER DATA BY VISIBLE AND STICKIED ********/
+    private getVoronoiData;
+    /******** HIGHLIGHT FOCUSED GROUP ********/
+    private labelMouseOver;
+    /******** UNHIGHLIGHT FOCUSED GROUP ********/
+    private labelMouseOut;
+    /******** FILTER DATA, ONLY KEEPING POINTS WITH ALL REQUIRED MEASURES ********/
+    private cleanData;
+    /******** UPDATE CHART DIMENSIONS ********/
+    private setWidthAndHeight;
+    /******** SCALE AND DRAW AXIS ********/
+    private drawAxis;
+    /******** DRAW X AND Y AXIS LABELS ********/
+    private drawAxisLabels;
+    /******** DRAW TOOLTIP IF ENABLED ********/
+    private drawTooltip;
+    /******** HELPERS TO FORMAT TIME DISPLAY ********/
+    private labelFormatUsesSeconds;
+    private labelFormatUsesMillis;
+}
+
+declare class GroupedBarChart extends ChartVisualizationComponent {
+    private contextMenu;
+    private setStateFromData;
+    private timestamp;
+    private isStacked;
+    private stackedButton;
+    chartComponentData: GroupedBarChartData;
+    constructor(renderTarget: Element);
+    GroupedBarChart(): void;
+    render(data: any, options: any, aggregateExpressionOptions: any): void;
+}
+
+declare class Grid extends Component {
+    private gridComponent;
+    private rowLabelKey;
+    private colorKey;
+    private aggIndexKey;
+    private chartComponentData;
+    private draw;
+    private closeButton;
+    private filteredTimestamps;
+    private table;
+    private tableHeaderRow;
+    private tableContentRows;
+    usesSeconds: boolean;
+    usesMillis: boolean;
+    constructor(renderTarget: Element);
+    static hideGrid(renderTarget: any): void;
+    static showGrid(renderTarget: any, chartOptions: ChartOptions, aggregateExpressionOptions: any, chartComponentData: ChartComponentData): void;
+    static createGridEllipsisOption(renderTarget: any, chartOptions: ChartOptions, aggregateExpressionOptions: any, chartComponentData: ChartComponentData, labelText?: string): {
+        iconClass: string;
+        label: string;
+        action: () => void;
+        description: string;
+    };
+    Grid(): void;
+    private cellClass;
+    focus: (rowIdx: any, colIdx: any) => void;
+    renderFromAggregates(data: any, options: any, aggregateExpressionOptions: any, chartComponentData: any): void;
+    private getRowData;
+    private convertSeriesToGridData;
+    private getFormattedDate;
+    private setFilteredTimestamps;
+    private addHeaderCells;
+    private addValueCells;
+    render(data: any, options: any, aggregateExpressionOptions: any, chartComponentData?: ChartComponentData): void;
+    private arrowNavigate;
+}
+
+declare class Slider extends Component {
+    private sliderSVG;
+    sliderTextDiv: any;
+    private xScale;
+    private data;
+    private width;
+    private sliderWidth;
+    private selectedLabel;
+    private isAscendingTimePeriods;
+    private margins;
+    private height;
+    constructor(renderTarget: Element);
+    Slider(): void;
+    private getXPositionOfLabel;
+    private determineIfAscendingTimePeriods;
+    render(data: Array<any>, options: any, width: number, selectedLabel?: string): void;
+    remove(): void;
+    private onDrag;
+    private onDragEnd;
+    private setSelectedLabelAndGetLabelAction;
+    private setSliderTextDivLabel;
+    private setStateFromLabel;
+    private moveLeft;
+    private moveRight;
+}
+
+declare class HierarchyNode {
+    name: string;
+    markedName: string;
+    children: Array<HierarchyNode>;
+    parent: HierarchyNode;
+    isExpanded: boolean;
+    isSelected: boolean;
+    isLeaf: boolean;
+    childrenInFilter: boolean;
+    selfInFilter: boolean;
+    color: (n: HierarchyNode) => string;
+    click: (n: any) => void;
+    isLeafParent: boolean;
+    level: number;
+    constructor(name: string, level: number);
+    filter(filterText: any): void;
+    traverse(condition: (n: HierarchyNode) => boolean): any[];
+    colorify(el: any): void;
+}
+
+declare class Hierarchy extends Component {
+    private filterText;
+    private root;
+    private withContextMenu;
+    private contextMenu;
+    private clickedNode;
+    private hierarchyList;
+    constructor(renderTarget: Element);
+    render(data: any, options: any): void;
+    expandCollapseList: (node: HierarchyNode, el: any, isFromClick?: boolean, event?: any) => void;
+    buildTree(data: any): HierarchyNode;
+    private closeContextMenu;
+}
+
+declare class ChartDataOptions {
+    searchSpan: any;
+    color: string | Function;
+    alias: string;
+    contextMenu: any;
+    measureTypes: Array<string>;
+    interpolationFunction: string;
+    yExtent: any;
+    includeEnvelope: boolean;
+    includeDots: boolean;
+    visibilityState: Array<any>;
+    timeShift: string;
+    startAt: string;
+    dataType: string;
+    valueMapping: any;
+    height: number;
+    onElementClick: any;
+    eventElementType: any;
+    rollupCategoricalValues: boolean;
+    tooltipAttributes: Array<any>;
+    positionX: number;
+    positionY: number;
+    swimLane: number;
+    variableAlias: any;
+    connectPoints: boolean;
+    pointConnectionMeasure: string;
+    positionXVariableName: string;
+    positionYVariableName: string;
+    image: string;
+    isRawData: boolean;
+    isVariableAliasShownOnTooltip: boolean;
+    horizontalMarkers: Array<HorizontalMarker>;
+    constructor(optionsObject: Object);
+}
+
+declare class AggregateExpression extends ChartDataOptions {
+    measureObject: any;
+    splitByObject: any;
+    predicate: Object;
+    visibleSplitByCap: number;
+    constructor(predicateObject: any, measureObject: any, measureTypes: Array<string>, searchSpan: any, splitByObject: any, colorOrOptionsObject: any, alias?: string, contextMenu?: Array<any>);
+    toTsx(roundFromTo?: boolean): {};
+}
+
+declare class Heatmap extends TemporalXAxisComponent {
+    private lineHeight;
+    private splitByLabelWidth;
+    private heatmapWrapper;
+    private splitByLabels;
+    private heatmapCanvasMap;
+    private timeLabels;
+    private height;
+    private timeLabelsHeight;
+    private visibleAggs;
+    constructor(renderTarget: Element);
+    private focusOnEllipsis;
+    private createControlsPanel;
+    private chartControlsExist;
+    private addTimeLabels;
+    mouseover: (hoveredAggKey: any, hoveredSplitBy: any) => void;
+    mouseout: (selection: any, hoveredAggKey: any) => void;
+    render(data: any, chartOptions: any, aggregateExpressionOptions: any): void;
+    renderTimeLabels: (focusStartTime: any, focusEndTime: any, focusX1: any, focusX2: any, focusY: any, yOffset: any, shiftMillis: any) => void;
+}
+
+declare class EventsTable extends ChartComponent {
+    private eventsTable;
+    private eventsLegend;
+    private headers;
+    private maxVisibleIndex;
+    private isAscending;
+    private timestampColumnName;
+    private sortColumn;
+    private allSelectedState;
+    private eventsTableData;
+    private margins;
+    constructor(renderTarget: Element);
+    EventsTable(): void;
+    renderFromEventsTsx(eventsFromTsx: any, chartOptions: any): void;
+    render(events: any, chartOptions: any, fromTsx?: boolean): void;
+    renderLegend(): void;
+    setLegendColumnStates(): void;
+    getSelectAllState(): string;
+    setSelectAllState(): void;
+    private getFilteredColumnKeys;
+    private buildHeaders;
+    private adjustHeaderWidth;
+    private buildTable;
+    private formatValue;
+}
+
+declare class ModelSearch extends Component {
+    private hierarchies;
+    private clickedInstance;
+    private wrapper;
+    private types;
+    private instanceResults;
+    private usedContinuationTokens;
+    private contextMenu;
+    private currentResultIndex;
+    constructor(renderTarget: Element);
+    ModelSearch(): void;
+    render(environmentFqdn: string, getToken: any, hierarchyData: any, chartOptions: any): void;
+    handleKeydown(event: any, ap: any): void;
+    private closeContextMenu;
+    private stripHits;
+    private getInstanceHtml;
+}
+
+declare class DateTimePicker extends ChartComponent {
+    private calendar;
+    private calendarPicker;
+    private timeControls;
+    private minMillis;
+    private maxMillis;
+    private fromMillis;
+    private toMillis;
+    private fromMinutes;
+    private fromHours;
+    private toMinutes;
+    private toHours;
+    private onSet;
+    private onCancel;
+    private isValid;
+    private targetElement;
+    private dateTimeSelectionPanel;
+    private quickTimesPanel;
+    private isSettingStartTime;
+    private startRange;
+    private endRange;
+    private anchorDate;
+    private offsetName;
+    private fromInput;
+    private toInput;
+    private quickTimeArray;
+    constructor(renderTarget: Element);
+    private getCurrentQuickTime;
+    getQuickTimeText(quickTimeMillis: any): any;
+    private convertToCalendarDate;
+    private setNewOffset;
+    private onSaveOrCancel;
+    render(chartOptions: any, minMillis: number, maxMillis: number, fromMillis?: number, toMillis?: number, onSet?: any, onCancel?: any): void;
+    private updateDisplayedDateTimes;
+    private setFromQuickTimes;
+    private buildQuickTimesPanel;
+    private createTimeString;
+    private getTimeFormat;
+    updateFromAndTo(fromMillis: any, toMillis: any): void;
+    private createTimezonePicker;
+    private roundDay;
+    private setTimeRange;
+    private createCalendar;
+    private setSelectedQuickTimes;
+    private setFromDate;
+    private setToDate;
+    private setIsSaveable;
+    private adjustSecondsAndMillis;
+    private setFromMillis;
+    private setToMillis;
+    private displayRangeErrors;
+    private rangeIsValid;
+    private updateDisplayedFromDateTime;
+    private updateDisplayedToDateTime;
+    private offsetUTC;
+    private offsetFromUTC;
+    private checkDateTimeValidity;
+    private setTimeInputBox;
+    private createTimePicker;
+}
+
+declare class TimezonePicker extends ChartComponent {
+    private targetElement;
+    private timeZones;
+    constructor(renderTarget: Element);
+    private sortTimezones;
+    render(onTimezoneSelect: any, defaultTimeZone?: string): void;
+}
+
+declare class TsqExpression extends ChartDataOptions {
+    private instanceObject;
+    private variableObject;
+    constructor(instanceObject: any, variableObject: any, searchSpan: any, colorOrOptionsObject: any, alias?: string, contextMenu?: Array<any>);
+    toTsq(roundFromTo?: boolean, getEvents?: boolean, getSeries?: boolean): {
+        getEvents: {};
+        getSeries?: undefined;
+        aggregateSeries?: undefined;
+    } | {
+        getSeries: {};
+        getEvents?: undefined;
+        aggregateSeries?: undefined;
+    } | {
+        aggregateSeries: {};
+        getEvents?: undefined;
+        getSeries?: undefined;
+    };
+    toStatsTsq(fromMillis: any, toMillis: any): {
+        getEvents: {};
+        getSeries?: undefined;
+        aggregateSeries?: undefined;
+    } | {
+        getSeries: {};
+        getEvents?: undefined;
+        aggregateSeries?: undefined;
+    } | {
+        aggregateSeries: {};
+        getEvents?: undefined;
+        getSeries?: undefined;
+    };
+}
+
+declare class ModelAutocomplete extends Component {
+    chartOptions: any;
+    ap: any;
+    constructor(renderTarget: Element);
+    render(environmentFqdn: string, getToken: any, chartOptions: any): void;
+}
+
+declare class HierarchyNavigation extends Component {
+    private searchFunction;
+    private hierarchyElem;
+    private path;
+    selectedIds: Array<string>;
+    searchEnabled: boolean;
+    private searchWrapperElem;
+    private hierarchyNavWrapper;
+    ap: any;
+    constructor(renderTarget: Element);
+    render(searchF: Function, hierarchyNavOptions: any, preselectedIds: Array<string>): Promise<void>;
+    private createHierarchyNavWrapper;
+    private createResultsWrapper;
+    private createHierarchyElem;
+    private requestPayload;
+    private renderTree;
+    private renderSearchBox;
+    private pathSearchAndRenderResult;
+    private renderSearchResult;
+    private filterTree;
+    private fillDataRecursively;
+    private createHierarchyItemElem;
+    private getAriaLabel;
+    private hierarchyNodeIdentifier;
+    private instanceNodeIdentifier;
+    private instanceNodeStringToDisplay;
+    private instanceNodeString;
+}
+
+declare class SingleDateTimePicker extends ChartComponent {
+    private calendar;
+    private calendarPicker;
+    private timeControls;
+    private minMillis;
+    private maxMillis;
+    private millis;
+    private minutes;
+    private hours;
+    private onSet;
+    private targetElement;
+    private isValid;
+    private offsetName;
+    private date;
+    private timeInput;
+    private saveButton;
+    constructor(renderTarget: Element);
+    getMillis(): number;
+    render(chartOptions: any, minMillis: number, maxMillis: number, millis?: number, onSet?: any): void;
+    private roundDay;
+    private setSelectedDate;
+    private createCalendar;
+    private setDate;
+    private setIsValid;
+    private setMillis;
+    private displayErrors;
+    private checkDateTimeValidity;
+    private dateTimeIsValid;
+    private getTimeFormat;
+    private parseUserInputDateTime;
+    private convertToCalendarDate;
+    private updateDisplayedDateTime;
+    private createTimeString;
+    private convertToLocal;
+    private createTimePicker;
+}
+
+declare class DateTimeButton extends ChartComponent {
+    protected dateTimePicker: any;
+    private pickerIsVisible;
+    protected minMillis: number;
+    protected maxMillis: number;
+    protected onSet: any;
+    protected dateTimeButton: any;
+    protected dateTimePickerContainer: any;
+    constructor(renderTarget: Element);
+    protected buttonDateTimeFormat(millis: any): string;
+    render(chartOptions: any, minMillis: any, maxMillis: any, onSet?: any): void;
+}
+
+declare class DateTimeButtonSingle extends DateTimeButton {
+    private selectedMillis;
+    constructor(renderTarget: Element);
+    private closeSDTP;
+    private sDTPOnSet;
+    render(chartOptions: any, minMillis: number, maxMillis: number, selectedMillis?: number, onSet?: any): void;
+}
+
+declare class DateTimeButtonRange extends DateTimeButton {
+    private onCancel;
+    private fromMillis;
+    private toMillis;
+    constructor(renderTarget: Element);
+    private setButtonText;
+    private onClose;
+    render(chartOptions: any, minMillis: number, maxMillis: number, fromMillis?: number, toMillis?: number, onSet?: any, onCancel?: any): void;
+}
+
+interface IPlaybackSettings {
+    intervalMillis: number;
+    stepSizeMillis: number;
+}
+declare class PlaybackControls extends Component {
+    private playbackInterval;
+    private playButton;
+    private handleElement;
+    private controlsContainer;
+    private track;
+    private trackXOffset;
+    private trackYOffset;
+    private trackWidth;
+    private timeFormatter;
+    private selectedTimeStamp;
+    private selectTimeStampCallback;
+    private timeStampToPosition;
+    private playbackSettings;
+    private end;
+    private wasPlayingWhenDragStarted;
+    readonly handleRadius: number;
+    readonly minimumPlaybackInterval: number;
+    constructor(renderTarget: Element, initialTimeStamp?: Date);
+    get currentTimeStamp(): Date;
+    render(start: Date, end: Date, onSelectTimeStamp: (d: Date) => {}, options: any, playbackSettings: IPlaybackSettings): void;
+    play(): void;
+    pause(): void;
+    next(): void;
+    private clamp;
+    private onDrag;
+    private onDragEnd;
+    private updateSelection;
+}
+
+declare class TsqRange {
+    from: Date;
+    to: Date;
+    private bucketSizeMs;
+    static NeatIntervals: string[];
+    static NeatIntervalsMs: number[];
+    constructor(from: Date, to: Date);
+    setNeatBucketSizeByNumerOfBuckets(targetNumberOfBuckets: number): void;
+    setNeatBucketSizeByRoughBucketSize(roughBucketSizeMillis: number): void;
+    alignWithServerEpoch(): void;
+    get fromMillis(): number;
+    get toMillis(): number;
+    get bucketSizeMillis(): number;
+    get bucketSizeStr(): string;
+    static millisToLargestUnit(interval: number): {
+        value: number;
+        unit: string;
+    };
+}
+
+type d3Selection = d3.Selection<d3.BaseType, unknown, null, undefined>;
+interface GraphicInfo {
+    graphic: any;
+    width: number;
+    height: number;
+}
+declare abstract class HistoryPlayback extends Component {
+    protected targetElement: d3Selection;
+    protected tsqExpressions: Array<TsqExpression>;
+    protected componentContainer: d3Selection;
+    protected component: d3Selection;
+    protected playbackControlsContainer: d3Selection;
+    protected playbackControls: PlaybackControls;
+    protected graphicOriginalWidth: number;
+    protected graphicOriginalHeight: number;
+    protected currentCancelTrigger: Function;
+    protected availabilityInterval: number;
+    protected environmentFqdn: string;
+    protected availability: TsqRange;
+    protected getAuthToken: () => Promise<string>;
+    protected playbackRate: number;
+    protected graphic: any;
+    readonly numberOfBuckets = 1000;
+    readonly defaultPlaybackRate = 3000;
+    readonly fetchAvailabilityFrequency = 30000;
+    readonly playbackSliderHeight = 88;
+    readonly previewApiFlag = "?api-version=2018-11-01-preview";
+    constructor(renderTarget: Element);
+    protected abstract loadResources(): Promise<any>;
+    protected abstract draw(): any;
+    protected abstract updateDataMarkers(data: Array<any>): void;
+    protected abstract getDataPoints(data: Array<any>): void;
+    protected onGraphicLoaded(): void;
+    protected renderBase(environmentFqdn: string, getToken: () => Promise<string>, data: Array<TsqExpression>, chartOptions: any): void;
+    pauseAvailabilityUpdates(): void;
+    private onSelecTimestamp;
+    private calcQueryWindow;
+    protected drawBase(): void;
+    private updateAvailability;
+}
+
+declare class ProcessGraphic extends HistoryPlayback {
+    private graphicSrc;
+    constructor(renderTarget: Element);
+    render(environmentFqdn: string, getToken: () => Promise<string>, graphicSrc: string, data: Array<TsqExpression>, chartOptions: any): void;
+    protected loadResources(): Promise<GraphicInfo>;
+    protected draw(): void;
+    private getResizedImageDimensions;
+    protected getDataPoints(results: Array<IProcessGraphicLabelInfo>): void;
+    protected updateDataMarkers(graphicValues: Array<IProcessGraphicLabelInfo>): void;
+    protected parseTsqResponse(response: any): any;
+    protected sanitizeAttribute(str: any): string;
+}
+interface IProcessGraphicLabelInfo {
+    value: number;
+    alias: string;
+    x: number;
+    y: number;
+    color: string;
+    onClick: Function;
+}
+
+interface ColorPickerOptions {
+    theme?: string;
+    numberOfColors?: number;
+    colors?: Array<string>;
+    defaultColor?: string;
+    isColorValueHidden?: boolean;
+    onSelect?: (colorHex: string) => void;
+    onClick?: (event: any) => void;
+}
+declare class ColorPicker extends Component {
+    private colorPickerElem;
+    private selectedColor;
+    private isColorGridVisible;
+    private componentId;
+    constructor(renderTarget: Element, componentId?: string);
+    render(options?: ColorPickerOptions): void;
+    getSelectedColorValue: () => string;
+    private showColorGrid;
+    hideColorGrid: (withFocusBackToPickerButton?: boolean) => void;
+    private setSelectedColor;
+    getColorPickerElem: () => any;
+}
+
+declare class GeoProcessGraphic extends HistoryPlayback {
+    private azureMapsSubscriptionKey;
+    private zoom;
+    private width;
+    private height;
+    private theme;
+    private center;
+    private bearing;
+    private pitch;
+    private maxZoom;
+    private minZoom;
+    private duration;
+    constructor(renderTarget: Element);
+    render(environmentFqdn: string, getToken: () => Promise<string>, data: Array<TsqExpression>, chartOptions: any): void;
+    protected loadResources(): Promise<any>;
+    protected draw(): void;
+    protected getDataPoints(results: Array<IGeoProcessGraphicLabelInfo>): void;
+    protected parseTsqResponse(response: any): {};
+    protected updateDataMarkers(dataPoints: Array<any>): void;
+    protected createTable(dataPointArr: any, idx: any): HTMLDivElement;
+}
+interface IGeoProcessGraphicLabelInfo {
+}
+
+declare class UXClient {
+    UXClient(): void;
+    DateTimePicker: typeof DateTimePicker;
+    PieChart: typeof PieChart;
+    ScatterPlot: typeof ScatterPlot;
+    BarChart: typeof GroupedBarChart;
+    LineChart: typeof LineChart;
+    AvailabilityChart: typeof AvailabilityChart;
+    Grid: typeof Grid;
+    Slider: typeof Slider;
+    Hierarchy: typeof Hierarchy;
+    AggregateExpression: typeof AggregateExpression;
+    TsqExpression: typeof TsqExpression;
+    Heatmap: typeof Heatmap;
+    EventsTable: typeof EventsTable;
+    ModelSearch: typeof ModelSearch;
+    ModelAutocomplete: typeof ModelAutocomplete;
+    HierarchyNavigation: typeof HierarchyNavigation;
+    TimezonePicker: typeof TimezonePicker;
+    EllipsisMenu: typeof EllipsisMenu;
+    SingleDateTimePicker: typeof SingleDateTimePicker;
+    DateTimeButtonSingle: typeof DateTimeButtonSingle;
+    DateTimeButtonRange: typeof DateTimeButtonRange;
+    ProcessGraphic: typeof ProcessGraphic;
+    PlaybackControls: typeof PlaybackControls;
+    ColorPicker: typeof ColorPicker;
+    GeoProcessGraphic: typeof GeoProcessGraphic;
+    transformTsxToEventsArray(events: any, options: any): any[];
+    private toISONoMillis;
+    transformAvailabilityForVisualization(availabilityTsx: any): Array<any>;
+    transformAggregatesForVisualization(aggregates: Array<any>, options: any): Array<any>;
+    createEntityKey(aggName: string, aggIndex?: number): string;
+    transformTsqResultsToEventsArray(results: any): any[];
+}
+
+declare class ContextMenu extends Component {
+    drawChart: any;
+    contextMenuElement: any;
+    actions: any;
+    contextMenuVisible: boolean;
+    startTime: any;
+    endTime: any;
+    private left;
+    private top;
+    private ae;
+    private splitBy;
+    private onClick;
+    private subMenuFromSubLevel;
+    private subMenuFromActionIndex;
+    constructor(drawChart: any, renderTarget: Element);
+    private launchSubMenu;
+    private positionAEC;
+    private shouldHorizontalFlip;
+    private shouldVerticalFlip;
+    private getRelativeHorizontalPosition;
+    private verticalPositionAEC;
+    private horizontalPositionAEC;
+    private getActionElementContainerTop;
+    private removeSubMenusAboveLevel;
+    private createActionElements;
+    draw(chartComponentData: any, renderTarget: any, options: any, mousePosition: any, aggKey: any, splitBy: any, onClick?: any, startTime?: any, endTime?: any, event?: any): void;
+    hide(): void;
+}
+
+declare class Tooltip extends Component {
+    private tooltipDiv;
+    private tooltipDivInner;
+    private tooltipText;
+    draw: any;
+    private borderColor;
+    constructor(renderTarget: any);
+    hide(): void;
+    private getSVGWidth;
+    private getSVGHeight;
+    private getLeftOffset;
+    private getTopOffset;
+    private isRightOffset;
+    private isTopOffset;
+    render(theme: any): void;
+}
+
+declare class Marker extends Component {
+    private markerContainer;
+    private timeLabel;
+    private closeButton;
+    private markerLabel;
+    private x;
+    private timestampMillis;
+    private chartHeight;
+    private chartMargins;
+    private chartComponentData;
+    private marginLeft;
+    private colorMap;
+    private yMap;
+    onChange: any;
+    private tooltipMap;
+    private guid;
+    private labelText;
+    private markerIsDragging;
+    private timeFormat;
+    private isSeriesLabels;
+    readonly ADDITIONALRIGHTSIDEOVERHANG = 12;
+    constructor(renderTarget: any);
+    getGuid(): string;
+    setMillis(millis: number): void;
+    getMillis(): number;
+    setLabelText(labelText: string): boolean;
+    getLabelText(): string;
+    private setSeriesLabelText;
+    protected tooltipFormat(d: any, text: any, measureFormat: TooltipMeasureFormat, xyrMeasures?: any, isSeriesLabelInFocus?: boolean): void;
+    private getLeft;
+    private isMarkerDragOccuring;
+    private bumpMarker;
+    private renderMarker;
+    private getValueOfVisible;
+    private getTooltipKey;
+    private findYatX;
+    private positionToValue;
+    private bisectionInterpolateValue;
+    private getPath;
+    private createNewDatum;
+    private findGapPath;
+    private inBounds;
+    private getIntersectingPath;
+    private interpolateValue;
+    private getValuesAtTime;
+    private setValueLabels;
+    private calcTopOfValueLabel;
+    private getTimeFormat;
+    private setTimeLabel;
+    focusCloseButton(): void;
+    isMarkerInRange(millis?: number): boolean;
+    destroyMarker(): void;
+    render(timestampMillis: number, chartOptions: ChartOptions, chartComponentData: any, additionalMarkerFields: {
+        chartMargins: any;
+        x: any;
+        marginLeft: number;
+        colorMap: any;
+        yMap: any;
+        onChange: any;
+        isDropping: boolean;
+        chartHeight: number;
+        labelText: string;
+        isSeriesLabels: boolean;
+    }): void;
+    setPositionsAndLabels(millis: number): void;
+}
+
+declare class Plot extends Component {
+    protected chartHeight: any;
+    protected x: any;
+    protected chartDataOptions: any;
+    protected chartComponentData: any;
+    protected yTop: any;
+    protected height: any;
+    protected aggregateGroup: any;
+    protected backdropRect: any;
+    protected plotDataType: string;
+    constructor(renderTarget: Element);
+    protected getVisibleSeries(aggKey: any): string[];
+    protected createGradientKey(d: any, splitByIndex: any, i: any): string;
+    protected addGradientStops(d: any, gradient: any): void;
+    protected createBackdropRect(isVisible: any): void;
+    protected getColorForValue(value: any): any;
+    protected getVisibleMeasures(measures: any): string[];
+    protected hasData(d: any): boolean;
+}
+
+declare class AxisState {
+    axisType: any;
+    yExtent: [number, number];
+    positionInGroup: number;
+    constructor(axisType: any, yExtent: [number, number], positionInGroup: number);
+}
+
+declare class LinePlot extends Plot {
+    private defs;
+    private chartWidth;
+    private y;
+    private visibleAggCount;
+    private strokeOpacity;
+    private previousIncludeDots;
+    private areaPath;
+    private yAxisState;
+    constructor(svgSelection: any);
+    private getXPosition;
+    private createAreaPath;
+    render(chartOptions: any, visibleAggI: any, agg: any, aggVisible: boolean, aggregateGroup: any, chartComponentData: any, yAxisState: AxisState, chartHeight: any, visibleAggCount: any, colorMap: any, previousAggregateData: any, x: any, areaPath: any, strokeOpacity: any, y: any, yMap: any, defs: any, chartDataOptions: any, previousIncludeDots: any, yTopAndHeight: any, svgSelection: any, categoricalMouseover: any, categoricalMouseout: any, yAxisOnClick: any): void;
+}
+
+declare class EventsPlot extends Plot {
+    private defs;
+    private hoverLine;
+    private chartGroup;
+    private discreteEventsMouseover;
+    private discreteEventsMouseout;
+    private splitBysGroup;
+    private eventHeight;
+    private gradientData;
+    private aggKey;
+    private gradientArray;
+    constructor(svgSelection: any);
+    private onMouseover;
+    private onMouseout;
+    private createHoverLine;
+    private setEventHeight;
+    private eventOnClick;
+    private colorFunction;
+    private createDateStringFunction;
+    private createEventElements;
+    private shouldDrawBackdrop;
+    render(chartOptions: any, visibleAggI: any, agg: any, aggVisible: boolean, aggregateGroup: any, chartComponentData: any, yExtent: any, chartHeight: any, visibleAggCount: any, colorMap: any, previousAggregateData: any, x: any, areaPath: any, strokeOpacity: any, y: any, yMap: any, defs: any, chartDataOptions: any, previousIncludeDots: any, yTopAndHeight: any, chartGroup: any, discreteEventsMouseover: any, discreteEventsMouseout: any): void;
+}
+
+declare class CategoricalPlot extends Plot {
+    private defs;
+    private hoverRect;
+    private chartGroup;
+    private categoricalMouseover;
+    private categoricalMouseout;
+    private splitBysGroup;
+    constructor(svgSelection: any);
+    private onMouseover;
+    private onMouseout;
+    private createHoverRect;
+    private getSeriesEndDate;
+    private getBucketEndDate;
+    render(chartOptions: any, visibleAggI: any, agg: any, aggVisible: boolean, aggregateGroup: any, chartComponentData: any, yExtent: any, chartHeight: any, visibleAggCount: any, colorMap: any, previousAggregateData: any, x: any, areaPath: any, strokeOpacity: any, y: any, yMap: any, defs: any, chartDataOptions: any, previousIncludeDots: any, yTopAndHeight: any, chartGroup: any, categoricalMouseover: any, categoricalMouseout: any): void;
+}
+
+declare class HeatmapCanvas extends ChartComponent {
+    private heatmapData;
+    private canvas;
+    private ctx;
+    private height;
+    private rawCellWidth;
+    private cellWidthMod;
+    private rawCellHeight;
+    private cellHeightMod;
+    private colorLegend;
+    private colorScale;
+    private gradientWidth;
+    private aggKey;
+    private focusedXIndex;
+    private focusedYIndex;
+    private focusedText;
+    private highlightedSplitBy;
+    private highlightedTime;
+    private highlightedValue;
+    private onCellFocus;
+    private aggI;
+    private isOnlyAgg;
+    constructor(renderTarget: any);
+    private renderScale;
+    private getExtent;
+    render(data: any, chartOptions: any, aggKey: any, highlightedSplitBy: string, highlightedTime: Date, onCellFocus: any, aggI: number, isOnlyAgg: boolean): void;
+    private calcCellXIndex;
+    private calcCellYIndex;
+    private calcCellHeight;
+    private calcCellX;
+    private calcCellWidth;
+    private calcCellY;
+    private drawCell;
+    private getColor;
+}
+
+declare class HeatmapData {
+    chartComponentData: ChartComponentData;
+    visibleSBs: Array<any>;
+    timeStamps: Array<Date>;
+    colorScale: any;
+    from: Date;
+    to: Date;
+    bucketSize: number;
+    timeValues: any;
+    aggKey: string;
+    numRows: number;
+    numCols: number;
+    allValues: Array<any>;
+    constructor(chartComponentData: ChartComponentData, aggKey: string);
+    private adjustStartTime;
+    private createTimeValues;
+}
+
+declare class TimeSeriesEvent {
+    cells: {};
+    constructor(rawEvent: any, offset?: any, offsetName?: string, locale?: string);
+}
+
+declare class EventsTableData {
+    columns: {};
+    rows: any[];
+    events: Array<TimeSeriesEvent>;
+    private timestampColumnKey;
+    private offsetName;
+    private maxVisibleToStart;
+    private offsetNameCache;
+    private timeSeriesIdProperties;
+    constructor();
+    private createOffsetName;
+    sortColumnKeys(): any[];
+    setEvents(rawEvents: any, fromTsx: any, timeSeriesIdProperties: any, offset?: any): void;
+    sortEvents(columnKey: any, isAscending: any): void;
+    constructColumns(): void;
+    generateCSVString(includeAllColumns?: boolean, offset?: number): string;
+}
+
+declare class TimeSeriesEventCell {
+    key: string;
+    name: string;
+    type: string;
+    value: any;
+    constructor(name: string, value: any, type?: string);
+}
+
+declare class Utils {
+    static guidForNullTSID: string;
+    static formatYAxisNumber(val: number): any;
+    static getStackStates(): typeof YAxisStates;
+    static parseTimeInput(inputString: string): number;
+    static findClosestTime(prevMillis: number, timeMap: any): number;
+    static getValueOfVisible(d: any, visibleMeasure: string): any;
+    static isStartAt(startAtString?: string, searchSpan?: any): boolean;
+    static parseShift(shiftString: string, startAtString?: any, searchSpan?: any): number;
+    static adjustStartMillisToAbsoluteZero(fromMillis: any, bucketSize: any): number;
+    static bucketSizeToTsqInterval(bucketSize: string): string;
+    static createEntityKey(aggName: string, aggIndex: number): string;
+    static getColorForValue(chartDataOptions: any, value: any): any;
+    static rollUpContiguous(data: any): any;
+    static formatOffsetMinutes(offset: any): string;
+    static getOffsetMinutes(offset: any, millis: number): any;
+    static offsetUTC(date: Date): Date;
+    static getMinutesToUTC(offset: any, millisInOffset: number): number;
+    static addOffsetGuess(timezoneName: any): string;
+    static timezoneAbbreviation(timezoneName: any): string;
+    static createTimezoneAbbreviation(offset: any): string;
+    static parseTimezoneName(timezoneRaw: any): any;
+    static convertTimezoneToLabel(timezone: any, locdLocal?: string): string;
+    static rangeTimeFormat(rangeMillis: number): string;
+    static subDateTimeFormat(is24HourTime: any, usesSeconds: any, usesMillis: any): string;
+    static timeFormat(usesSeconds?: boolean, usesMillis?: boolean, offset?: any, is24HourTime?: boolean, shiftMillis?: number, timeFormat?: string, locale?: string): (d: any) => string;
+    static splitTimeLabel(text: any): void;
+    static getUTCHours(d: Date, is24HourTime?: boolean): number;
+    static UTCTwelveHourFormat(d: Date): string;
+    static getAgVisible(displayState: any, aggI: string, splitBy: string): any;
+    static getAgVisibleMeasure(displayState: any, aggI: string, splitBy: string): any;
+    static createSeriesTypeIcon(seriesType: string, selection: any): void;
+    static strip(text: any): string;
+    static stripForConcat(text: any): any;
+    static setSeriesLabelSubtitleText(subtitle: any, isInFocus?: boolean): void;
+    static revertAllSubtitleText(markerValues: any, opacity?: number): void;
+    static generateColors(numColors: number, includeColors?: string[]): any[];
+    static convertFromLocal(date: Date): Date;
+    static adjustDateFromTimezoneOffset(date: Date): Date;
+    static offsetFromUTC(date: Date, offset?: number): Date;
+    static offsetToUTC(date: Date, offset?: number): Date;
+    static parseUserInputDateTime(timeText: any, offset: any): number;
+    static getBrighterColor(color: string): any;
+    static createSplitByColors(displayState: any, aggKey: string, ignoreIsOnlyAgg?: boolean): any[];
+    static colorSplitBy(displayState: any, splitByIndex: number, aggKey: string, ignoreIsOnlyAgg?: boolean): any;
+    static getTheme(theme: any): string;
+    static clearSelection(): void;
+    static mark(filter: any, text: any): any;
+    static hash(str: any): number;
+    static guid(): string;
+    static createValueFilter(aggregateKey: any, splitBy: any): (d: any, j: number) => boolean;
+    static downloadCSV(csvString: string, csvName?: string): void;
+    static sanitizeString(str: any, type: String): any;
+    static focusOnEllipsisButton(renderTarget: any): void;
+    static createDownloadEllipsisOption(csvStringGenerator: any, action?: () => void, downloadLabel?: string): {
+        iconClass: string;
+        label: string;
+        action: () => void;
+        description: string;
+    };
+    static createControlPanel(renderTarget: any, legendWidth: number, topChartMargin: number, chartOptions: any): any;
+    static escapeQuotesCommasAndNewlines(stringToEscape: string): string;
+    static getNonNumericHeight(rawHeight: number): number;
+    static getControlPanelWidth(renderTarget: any, legendWidth: any, isLegendShown: any): number;
+    static getValueOrDefault(chartOptionsObj: any, propertyName: any, defaultValue?: any): any;
+    static safeNotNullOrUndefined(valueLambda: any): boolean;
+    static equalToEventTarget: (current: any, event: any) => boolean;
+    static getAggKeys(data: any): any;
+    static roundToMillis(rawTo: any, bucketSize: any): number;
+    static mergeSeriesForScatterPlot(chartData: any, scatterMeasures: any): {
+        [x: string]: {
+            "": {};
+        };
+    };
+    static getScatterPlotMeasureNames(chartData: any, scatterMeasures: any): {
+        X_MEASURE: string;
+        Y_MEASURE: string;
+        R_MEASURE: string;
+    };
+    static isKeyDownAndNotEnter: (e: any) => boolean;
+    static getMinWarmTime(warmStoreFrom: any, retentionString: any): Date;
+    static standardizeTSStrings(rawData: any): any[];
+    static cullValuesOutOfRange(availabilityDistribution: any, minDateString: string, maxDateString: string): any[];
+    static mergeAvailabilities(warmAvailability: any, coldAvailability: any, retentionString?: any): any;
+    static languageGuess(): string;
+    static getInstanceKey: (instance: any) => any;
+    static stripNullGuid: (str: any) => any;
+    static getTimeSeriesIdString: (instance: any) => any;
+    static getTimeSeriesIdToDisplay: (instance: any, emptyDisplayString: any) => any;
+    static getHighlightedTimeSeriesIdToDisplay: (instance: any) => any;
+    static instanceHasEmptyTSID: (instance: any) => boolean;
+    static appendFormattedElementsFromString: (targetElem: any, str: any, options?: {
+        additionalClassName?: string;
+        inSvg?: boolean;
+        splitByTag?: string;
+    }) => void;
+    static escapedTsidForExactSearch: (tsid: string) => string;
+    static memorySizeOf(obj: any): number;
+}
+
+export { AggregateExpression, AvailabilityChart, AxisState, CategoricalPlot, ChartComponentData, ChartDataOptions, ChartOptions, ColorPicker, ContextMenu, DateTimeButtonRange, DateTimeButtonSingle, DateTimePicker, EllipsisMenu, EventsPlot, EventsTable, EventsTableData, GeoProcessGraphic, Grid, GroupedBarChart, GroupedBarChartData, Heatmap, HeatmapCanvas, HeatmapData, Hierarchy, HierarchyNavigation, HierarchyNode, HistoryPlayback, Legend, LineChart, LineChartData, LinePlot, Marker, ModelAutocomplete, ModelSearch, PieChart, PieChartData, PlaybackControls, ProcessGraphic, ScatterPlot, ScatterPlotData, SingleDateTimePicker, Slider, Strings, TimeSeriesEvent, TimeSeriesEventCell, TimezonePicker, Tooltip, TsqExpression, TsqRange, UXClient, Utils, UXClient as default };