import { OnDestroy, ViewContainerRef, NgZone, ComponentFactoryResolver, Renderer2, Injector, EventEmitter, QueryList } from '@angular/core';
import { XamDoughnutChart } from './XamDoughnutChart';
import { IgPoint } from "igniteui-angular-core";
import { IgxSliceClickEventArgs } from "./igx-slice-click-event-args";
import { IgxHoleDimensionsChangedEventArgs } from "./igx-hole-dimensions-changed-event-args";
import { IgxRingSeriesBaseComponent } from "./igx-ring-series-base-component";
import { IgxRingSeriesCollection } from "./igx-ring-series-collection";
export declare const IgxDoughnutChartComponent_PROVIDERS: any[];
/**
 * Represents concentric circles divided on arcs  depending on data.
*/
export declare class IgxDoughnutChartComponent implements OnDestroy {
    private renderer;
    private _elRef;
    private ngZone;
    private injector;
    private componentFactoryResolver;
    container: Element;
    contentSeries: QueryList<IgxRingSeriesBaseComponent>;
    _dynamicContent: ViewContainerRef;
    private _height;
    private _width;
    height: string;
    width: string;
    constructor(renderer: Renderer2, _elRef: ViewContainerRef, ngZone: NgZone, injector: Injector, componentFactoryResolver: ComponentFactoryResolver);
    ngOnDestroy(): void;
    private _wrapper;
    private onImplementationCreated;
    protected createImplementation(): XamDoughnutChart;
    protected _implementation: any;
    readonly i: XamDoughnutChart;
    protected createSeriesComponent(type: string): any;
    private _chart;
    ngAfterContentInit(): void;
    /**
     * 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: IgxRingSeriesBaseComponent[];
    private _seriesAdapter;
    private _series;
    /**
     * A collection or manually added series for the chart.
    */
    readonly series: IgxRingSeriesCollection;
    private _ensureTooltipCreated;
    private _defaultTooltips;
    private _ensureDefaultTooltip;
    private _onDefaultTooltipsReady;
    private createTooltip;
    /**
 * Gets or sets whether the slices can be selected.
*/
    allowSliceSelection: boolean;
    /**
     * Gets or sets whether all surface interactions with the plot area should be disabled.
    */
    isSurfaceInteractionDisabled: boolean;
    /**
     * Gets or sets whether the slices can be exploded.
    */
    allowSliceExplosion: boolean;
    /**
     * Gets or sets the inner extent of the doughnut chart. It is percent from the outer ring's radius.
    */
    innerExtent: number;
    /**
     * Gets or sets the fill brush.
    */
    selectedSliceFill: string;
    /**
     * Gets or sets the stroke brush.
    */
    selectedSliceStroke: string;
    /**
     * Gets or sets the stroke thickness.
    */
    selectedSliceStrokeThickness: number;
    /**
     * Gets or sets the opacity.
    */
    selectedSliceOpacity: 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.
    */
    pixelScalingRatio: 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.
    */
    actualPixelScalingRatio: number;
    protected __p: string;
    protected _hasUserValues: Set<string>;
    protected readonly 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;
    /**
     * Raised when the slice is clicked.
    */
    readonly sliceClick: EventEmitter<{
        sender: any;
        args: IgxSliceClickEventArgs;
    }>;
    private _holeDimensionsChanged;
    /**
     * Raised when the dimensions (center point or radius) of the doughnut hole change.
    */
    readonly holeDimensionsChanged: EventEmitter<{
        sender: any;
        args: IgxHoleDimensionsChangedEventArgs;
    }>;
    protected _zoneRunner: (act: () => void) => void;
    protected _runInZone(act: () => void): void;
}
