import * as rxjs from 'rxjs';
import * as i0 from '@angular/core';
import { ElementRef, OnChanges } from '@angular/core';
import { Selection, BaseType } from 'd3-selection';

/**
 * Base configuration for all charts.
 *    INewChart extends IChart
 */
declare class PcacChartConfig {
    /**
     * Height in pixels
     */
    data: PcacData[];
    height: number;
}
declare class PcacData {
    key: string | number | null;
    value: string | number | null;
    hide: boolean;
    data: PcacData[];
}
declare enum PcacFormatEnum {
    None = "none",
    Decimal = "decimal",
    DatasetLength = "datasetLength",
    Percentage = "percentage",
    Minutes = "minutes",
    DateTime = "dateTime",
    Fahrenheit = "fahrenheit",
    /**
     * Expectation is we will be given a range of data from 0-23
     * and we will map that to a 12 hour clock with am/pm
     * e.g. 0 = 12am, 1 = 1am, 13 = 1pm, 23 = 11pm
     */
    OneDayHours = "oneDayHours"
}

declare class PcacBarHorizontalChartConfig extends PcacChartConfig {
    domainMax: number;
    numberOfTicks: number;
    isStacked: boolean;
    thresholds: PcacData[];
    tickFormat: PcacFormatEnum;
    hideGrid: boolean;
    hideAxis: boolean;
    spreadColorsPerGroup: boolean;
    colorOverride: PcacBarHorizontalChartColorOverrideConfig;
}
declare class PcacBarHorizontalChartColorOverrideConfig {
    colors: string[];
}

interface IPcacAxisBuilderConfig {
    svg: Selection<BaseType, {}, HTMLElement, any>;
    height: number;
    xScale: any;
    yScale: any;
    numberOfTicks: number;
    yFormat?: PcacFormatEnum;
    xFormat?: PcacFormatEnum;
    hideYAxis?: boolean;
    hideXAxis?: boolean;
}
declare class PcacAxisBuilder {
    drawAxis(config: IPcacAxisBuilderConfig): void;
    drawYAxis(config: IPcacAxisBuilderConfig): void;
    drawXAxis(config: IPcacAxisBuilderConfig): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacAxisBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PcacAxisBuilder>;
}

interface IPcacGridBuilderConfig {
    svg: Selection<BaseType, {}, HTMLElement, any>;
    /**
     * Required for horizontal grid
     */
    width: number;
    /**
     * Required for vertical grid
     */
    height: number;
    xScale: any;
    yScale: any;
    numberOfTicks: number;
}
declare class PcacGridBuilder {
    drawVerticalGrid(config: IPcacGridBuilderConfig): void;
    drawHorizontalGrid(config: IPcacGridBuilderConfig): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacGridBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PcacGridBuilder>;
}

declare class PcacColorService {
    private primary;
    private primaryLight;
    private success;
    private danger;
    private warning;
    private orange;
    private blue;
    private scale;
    private alert;
    /**
     * Get a scale of colors dynamically
     * @param numberOfNodes Number of items in dynamically build collection of colors
     */
    getColorScale(numberOfNodes: number): string[];
    getAlert(): string;
    /**
     * Set the scale that charts use to set colors of data[x] on the UI.
     * @param colors A collection of hex values
     */
    setScale(colors: string[]): void;
    setPrimary(color: string): void;
    setPrimaryLight(color: string): void;
    setSuccess(color: string): void;
    setDanger(color: string): void;
    setOrange(color: string): void;
    setBlue(color: string): void;
    setAlert(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacColorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PcacColorService>;
}

declare class PcacTooltipBuilder {
    tooltip: any;
    showBarTooltip(event: MouseEvent, data: PcacData, valueFormat?: PcacFormatEnum, keyFormat?: PcacFormatEnum): void;
    hideTooltip(): void;
    private getBarTipData;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacTooltipBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PcacTooltipBuilder>;
}

declare class PcacTransitionService {
    private transitionDuration;
    getTransitionDuration(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacTransitionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PcacTransitionService>;
}

declare class PcacChart {
    axisBuilder: PcacAxisBuilder;
    gridBuilder: PcacGridBuilder;
    transitionService: PcacTransitionService;
    tooltipBuilder: PcacTooltipBuilder;
    colorService: PcacColorService;
    margin: {
        top: number;
        right: number;
        bottom: number;
        left: number;
    };
    svg: Selection<BaseType, {}, HTMLElement, any> | any;
    width: number;
    height: number;
    colors: string[];
    startData: any[];
    endData: any[];
    /**
     * Prior to building a chart, we need to initialize the state of the chart
     * @param chartElm Reference to SVG on dom
     * @param config Chart specific configuration
     */
    initializeChartState(chartElm: ElementRef, config: PcacChartConfig): void;
    /**
     * 1) Set the width and height of the SVG
     * 2) Add a group and translate it to state of {{center}} option
     * @param chartElm Reference to SVG on dom
     * @param center Are we pinning x,y to the top,left, or are we centering our drawing group inside the SVG.
     */
    buildContainer(chartElm: ElementRef, center?: boolean): void;
    /**
     * Most charts share a default margin(s) state.
     * In some cases, that state needs to be calculated based on the content that resides in that margin.
     * For example, labels on a horizontal bar chart are dynamic and such the margin needs to be calculated ahead of
     * chart axis construction.
     * @param chartElm Reference to SVG on dom
     * @param data Generic multi-dimensional PcacData structure
     * @param yScale D3 scale transformation object (d3.ScaleBand)
     */
    setHorizontalMarginsBasedOnContent(chartElm: ElementRef, data: PcacData[], yScale: any): void;
}

declare class BarHorizontalChartBuilder extends PcacChart {
    private xScale;
    private yScaleStacked;
    private yScaleGrouped;
    private barClickedSource;
    private config;
    private cachedMargins;
    barClicked$: rxjs.Observable<PcacData>;
    buildChart(chartElm: ElementRef, config: PcacBarHorizontalChartConfig): void;
    private adjustForHiddenAxis;
    private setStartState;
    private buildScales;
    private drawChart;
    private addGroups;
    private drawBarsPerGroup;
    private drawThresholdAcrossChart;
    private drawThresholdsPerGroup;
    private drawThresholdsPerBarInGroup;
    private applyPreTransitionThresholdStyles;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarHorizontalChartBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BarHorizontalChartBuilder>;
}

declare class PcacBarHorizontalChartComponent implements OnChanges {
    private chartBuilder;
    readonly config: i0.InputSignal<PcacBarHorizontalChartConfig>;
    readonly chartElm: i0.Signal<ElementRef<any>>;
    readonly barClicked: i0.OutputEmitterRef<PcacData>;
    private resizeWindowTimeout;
    constructor();
    ngOnChanges(): void;
    buildChart(): void;
    /**
     * Opting against fromEvent due to incompatibility with rxjs 5 => 6
     */
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacBarHorizontalChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PcacBarHorizontalChartComponent, "pcac-bar-horizontal-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "barClicked": "barClicked"; }, never, never, true, never>;
}

declare class PcacBarVerticalChartConfig extends PcacChartConfig {
    domainMax: number;
    numberOfTicks: number;
    isStacked: boolean;
    thresholds: PcacData[];
    tickFormat: PcacFormatEnum;
    hideGrid: boolean;
    hideAxis: boolean;
    spreadColorsPerGroup: boolean;
    colorOverride: PcacBarVerticalChartColorOverrideConfig;
}
declare class PcacBarVerticalChartColorOverrideConfig {
    colors: string[];
}

interface IBarVerticalChartBuilder {
    buildChart(chartElm: ElementRef, config: PcacBarVerticalChartConfig): void;
}
declare class BarVerticalChartBuilder extends PcacChart {
    private xScaleStacked;
    private xScaleGrouped;
    private yScale;
    private barClickedSource;
    barClicked$: rxjs.Observable<PcacData>;
    buildChart(chartElm: ElementRef, config: PcacBarVerticalChartConfig): void;
    private adjustForHiddenAxis;
    private hasGroupLabel;
    private buildScales;
    private drawChart;
    private addGroups;
    private drawBarsPerGroup;
    private drawThresholdAcrossChart;
    private drawThresholdsPerGroup;
    private drawThresholdsPerBarInGroup;
    private applyPreTransitionThresholdStyles;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarVerticalChartBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BarVerticalChartBuilder>;
}

declare class PcacBarVerticalChartComponent implements OnChanges {
    private chartBuilder;
    readonly config: i0.InputSignal<PcacBarVerticalChartConfig>;
    readonly chartElm: i0.Signal<ElementRef<any>>;
    readonly barClicked: i0.OutputEmitterRef<PcacData>;
    private resizeWindowTimeout;
    constructor();
    ngOnChanges(): void;
    buildChart(): void;
    /**
     * Opting against fromEvent due to incompatibility with rxjs 5 => 6
     */
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacBarVerticalChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PcacBarVerticalChartComponent, "pcac-bar-vertical-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "barClicked": "barClicked"; }, never, never, true, never>;
}

declare class PcacLegendConfigItem {
    label: string;
    checked: boolean;
    colorOverride: string | null;
}
declare class PcacLegendConfig {
    heading: string | null;
    items: PcacLegendConfigItem[];
}
declare class PcacLegend {
    readonly colorService: PcacColorService;
    config: i0.ModelSignal<PcacLegendConfig>;
    itemClicked: i0.OutputEmitterRef<PcacLegendConfigItem[]>;
    colorScale: i0.Signal<string[]>;
    onItemClicked(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacLegend, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PcacLegend, "pcac-legend", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "config": "configChange"; "itemClicked": "itemClicked"; }, never, never, true, never>;
}

declare enum PcacLineAreaPlotChartConfigType {
    Line = "line",
    Area = "area",
    Plot = "plot"
}
declare class PcacLineAreaChartConfig extends PcacChartConfig {
    enableEffects: boolean;
    enableZoom: boolean;
    numberOfTicks: number;
    hideGrid: boolean;
    hideAxis: boolean;
    yFormat: PcacFormatEnum;
    xFormat: PcacFormatEnum;
    yDomainMax: number | string;
    yDomainMin: number | string;
    xDomainMin: number | string;
    xDomainMax: number | string;
    /**
     * Hex color codes to override the default colors
     */
    colorOverride: string[];
}

declare class PcacPlotChartConfig extends PcacLineAreaChartConfig {
}

declare class PcacPlotChart {
    readonly config: i0.InputSignal<PcacPlotChartConfig>;
    readonly types: typeof PcacLineAreaPlotChartConfigType;
    readonly dotClicked: i0.OutputEmitterRef<PcacData>;
    private chart;
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacPlotChart, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PcacPlotChart, "pcac-plot-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dotClicked": "dotClicked"; }, never, never, true, never>;
}

declare class PcacLineChartConfig extends PcacLineAreaChartConfig {
}

declare class PcacLineChart {
    readonly config: i0.InputSignal<PcacLineChartConfig>;
    readonly types: typeof PcacLineAreaPlotChartConfigType;
    readonly dotClicked: i0.OutputEmitterRef<PcacData>;
    private chart;
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacLineChart, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PcacLineChart, "pcac-line-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dotClicked": "dotClicked"; }, never, never, true, never>;
}

declare class PcacAreaChartConfig extends PcacLineAreaChartConfig {
}

declare class PcacAreaChart {
    readonly config: i0.InputSignal<PcacAreaChartConfig>;
    readonly types: typeof PcacLineAreaPlotChartConfigType;
    readonly dotClicked: i0.OutputEmitterRef<PcacData>;
    private chart;
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacAreaChart, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PcacAreaChart, "pcac-area-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dotClicked": "dotClicked"; }, never, never, true, never>;
}

declare class PcacPieChartConfig extends PcacChartConfig {
    numberOfTicks: number;
}

declare class PieChartBuilder extends PcacChart {
    private radius;
    private arcShape;
    private arcOverShape;
    private pieAngles;
    private sliceClickedSource;
    sliceClicked$: rxjs.Observable<PcacData>;
    buildChart(chartElm: ElementRef, config: PcacPieChartConfig): void;
    private buildShapes;
    private drawChart;
    private tweenChart;
    static ɵfac: i0.ɵɵFactoryDeclaration<PieChartBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PieChartBuilder>;
}

declare class PcacPieChartComponent implements OnChanges {
    private chartBuilder;
    readonly config: i0.InputSignal<PcacPieChartConfig>;
    readonly chartElm: i0.Signal<ElementRef<any>>;
    readonly sliceClicked: i0.OutputEmitterRef<PcacData>;
    private resizeWindowTimeout;
    constructor();
    ngOnChanges(): void;
    buildChart(): void;
    /**
     * Opting against fromEvent due to incompatibility with rxjs 5 => 6
     */
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PcacPieChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PcacPieChartComponent, "pcac-pie-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "sliceClicked": "sliceClicked"; }, never, never, true, never>;
}

export { BarHorizontalChartBuilder, BarVerticalChartBuilder, PcacAreaChart, PcacAreaChartConfig, PcacAxisBuilder, PcacBarHorizontalChartColorOverrideConfig, PcacBarHorizontalChartComponent, PcacBarHorizontalChartConfig, PcacBarVerticalChartColorOverrideConfig, PcacBarVerticalChartComponent, PcacBarVerticalChartConfig, PcacChart, PcacChartConfig, PcacColorService, PcacData, PcacFormatEnum, PcacGridBuilder, PcacLegend, PcacLegendConfig, PcacLegendConfigItem, PcacLineChart, PcacLineChartConfig, PcacPieChartComponent, PcacPieChartConfig, PcacPlotChart, PcacPlotChartConfig, PcacTooltipBuilder, PcacTransitionService, PieChartBuilder };
export type { IBarVerticalChartBuilder, IPcacAxisBuilderConfig, IPcacGridBuilderConfig };