import * as React from 'react';
import { XamDoughnutChart } from './XamDoughnutChart';
import { IgPoint } from "igniteui-react-core";
import { IgrSliceClickEventArgs } from "./igr-slice-click-event-args";
import { IgrHoleDimensionsChangedEventArgs } from "./igr-hole-dimensions-changed-event-args";
import { IgrRingSeriesBase } from "./igr-ring-series-base";
import { IgrRingSeriesCollection } from "./igr-ring-series-collection";
/**
 * Represents concentric circles divided on arcs  depending on data.
*/
export declare class IgrDoughnutChart extends React.Component<IIgrDoughnutChartProps> {
    private container;
    contentSeries: IgrRingSeriesBase[];
    private _height;
    private _width;
    set height(value: string);
    get height(): string;
    set width(value: string);
    get width(): string;
    private _elRef;
    private _contentChildrenManager;
    private _updateContentChildren;
    private _contentChildren;
    private _contentChildrenActual;
    private _contentChildrenMap;
    private _contentChildrenUnresolved;
    protected _tooltipRef(t: any): void;
    render(): React.DetailedReactHTMLElement<{
        className: string;
        ref: (div: HTMLDivElement) => void;
        children: any[];
    }, HTMLDivElement>;
    componentDidMount(): void;
    shouldComponentUpdate(nextProps: any, nextState: any): boolean;
    private _renderer;
    private _getMainRef;
    constructor(props: IIgrDoughnutChartProps);
    destroy(): void;
    initializeContent(): void;
    componentWillUnmount(): void;
    private _wrapper;
    private onImplementationCreated;
    protected createImplementation(): XamDoughnutChart;
    protected _implementation: any;
    get i(): XamDoughnutChart;
    protected createSeriesComponent(type: string): any;
    private _chart;
    /**
     * The series actually present in the chart. Do not directly modify this array.
     * This array's contents can be modified by causing Angular to reproject the child content.
     * Or adding and removing series from the manual series collection on the series property.
     */
    actualSeries: IgrRingSeriesBase[];
    private _seriesAdapter;
    private _series;
    /**
     * A collection or manually added series for the chart.
    */
    get series(): IgrRingSeriesCollection;
    private _ensureTooltipCreated;
    private createWrapper;
    private _defaultTooltips;
    private _ensureDefaultTooltip;
    private _onDefaultTooltipsReady;
    private _activeTooltips;
    private _activeTooltipElements;
    private _currentTooltips;
    private _uniqueTooltipId;
    private createTooltip;
    private _updateTooltipState;
    /**
 * Gets or sets whether the slices can be selected.
*/
    get allowSliceSelection(): boolean;
    set allowSliceSelection(v: boolean);
    /**
     * Gets or sets whether all surface interactions with the plot area should be disabled.
    */
    get isSurfaceInteractionDisabled(): boolean;
    set isSurfaceInteractionDisabled(v: boolean);
    /**
     * Gets or sets whether the slices can be exploded.
    */
    get allowSliceExplosion(): boolean;
    set allowSliceExplosion(v: boolean);
    /**
     * Gets or sets the inner extent of the doughnut chart. It is percent from the outer ring's radius.
    */
    get innerExtent(): number;
    set innerExtent(v: number);
    /**
     * Gets or sets the fill brush.
    */
    get selectedSliceFill(): string;
    set selectedSliceFill(v: string);
    /**
     * Gets or sets the stroke brush.
    */
    get selectedSliceStroke(): string;
    set selectedSliceStroke(v: string);
    /**
     * Gets or sets the stroke thickness.
    */
    get selectedSliceStrokeThickness(): number;
    set selectedSliceStrokeThickness(v: number);
    /**
     * Gets or sets the opacity.
    */
    get selectedSliceOpacity(): number;
    set selectedSliceOpacity(v: number);
    ensureSelectedStyle(): void;
    /**
     * Gets or sets the scaling value used to affect the pixel density of the control.
     * A higher scaling ratio will produce crisper visuals at the expense of memory.  Lower values will cause the control
     * to appear blurry.
    */
    get pixelScalingRatio(): number;
    set pixelScalingRatio(v: number);
    /**
     * Resolved pixel scaling ratio. Unless explicitly overridden by the
     * IgxDoughnutChart.PixelScalingRatioComponent property,
     * this one returns the default ratio enforced by device. High resolution devices will initialize this property
     * to a higher value.
    */
    get actualPixelScalingRatio(): number;
    set actualPixelScalingRatio(v: number);
    findByName(name: string): any;
    protected __p: string;
    protected _hasUserValues: Set<string>;
    protected get hasUserValues(): Set<string>;
    protected __m(propertyName: string): void;
    protected _stylingContainer: any;
    protected _stylingParent: any;
    protected _inStyling: boolean;
    protected _styling(container: any, component: any, parent?: any): void;
    /**
 * Called by the UI framework to provide a UI container for rendering this control.

* @param container  * The UI container element.
*/
    provideContainer(container: any): void;
    /**
     * Called when the control has been resized.
    
    */
    notifyResized(): void;
    /**
     * Gets the ID of the UI container.
    
    */
    getContainerID(): string;
    /**
     * Gets the center coordinates of the doughnut chart's center presenter.
    
    */
    getCenterCoordinates(): IgPoint;
    /**
     * Gets the hole radius of the doughnut chart's center presenter.
    
    */
    getHoleRadius(): number;
    /**
     * Use to force the doughnut chart to finish any deferred work before printing or evaluating its visual.
     * This should only be called if the visual of the doughnut chart needs to be synchronously saved or evaluated.
     * Calling this method too often will hinder the performance of the doughnut chart.
    
    */
    flush(): void;
    /**
     * Returns the chart visuals expressed as a serialized string.
    
    */
    exportSerializedVisualData(): string;
    notifyInsertItem(source_: any, index: number, newItem: any): void;
    notifySetItem(source_: any, index: number, oldItem: any, newItem: any): void;
    /**
     * Used to manually notify the chart that the data source has reset or cleared its items.
    
    */
    notifyClearItems(source_: any): void;
    notifyRemoveItem(source_: any, index: number, oldItem: any): void;
    private _sliceClick;
    private _sliceClick_wrapped;
    /**
     * Raised when the slice is clicked.
    */
    get sliceClick(): (s: IgrDoughnutChart, e: IgrSliceClickEventArgs) => void;
    set sliceClick(ev: (s: IgrDoughnutChart, e: IgrSliceClickEventArgs) => void);
    private _holeDimensionsChanged;
    private _holeDimensionsChanged_wrapped;
    /**
     * Raised when the dimensions (center point or radius) of the doughnut hole change.
    */
    get holeDimensionsChanged(): (s: IgrDoughnutChart, e: IgrHoleDimensionsChangedEventArgs) => void;
    set holeDimensionsChanged(ev: (s: IgrDoughnutChart, e: IgrHoleDimensionsChangedEventArgs) => void);
}
export interface IIgrDoughnutChartProps {
    width?: string;
    height?: string;
    children?: React.ReactNode;
    /**
 * Gets or sets whether the slices can be selected.
*/
    allowSliceSelection?: boolean | string;
    /**
     * Gets or sets whether all surface interactions with the plot area should be disabled.
    */
    isSurfaceInteractionDisabled?: boolean | string;
    /**
     * Gets or sets whether the slices can be exploded.
    */
    allowSliceExplosion?: boolean | string;
    /**
     * Gets or sets the inner extent of the doughnut chart. It is percent from the outer ring's radius.
    */
    innerExtent?: number | string;
    /**
     * Gets or sets the fill brush.
    */
    selectedSliceFill?: string;
    /**
     * Gets or sets the stroke brush.
    */
    selectedSliceStroke?: string;
    /**
     * Gets or sets the stroke thickness.
    */
    selectedSliceStrokeThickness?: number | string;
    /**
     * Gets or sets the opacity.
    */
    selectedSliceOpacity?: number | string;
    /**
     * Gets or sets the scaling value used to affect the pixel density of the control.
     * A higher scaling ratio will produce crisper visuals at the expense of memory.  Lower values will cause the control
     * to appear blurry.
    */
    pixelScalingRatio?: number | string;
    /**
     * Resolved pixel scaling ratio. Unless explicitly overridden by the
     * IgxDoughnutChart.PixelScalingRatioComponent property,
     * this one returns the default ratio enforced by device. High resolution devices will initialize this property
     * to a higher value.
    */
    actualPixelScalingRatio?: number | string;
    /**
 * Raised when the slice is clicked.
*/
    sliceClick?: (s: IgrDoughnutChart, e: IgrSliceClickEventArgs) => void;
    /**
     * Raised when the dimensions (center point or radius) of the doughnut hole change.
    */
    holeDimensionsChanged?: (s: IgrDoughnutChart, e: IgrHoleDimensionsChangedEventArgs) => void;
}