import type { IAnimation } from "./util/Animation";
import type { Entity } from "./util/Entity";
import type { Sprite } from "./render/Sprite";
import type { Theme } from "./Theme";
import type { IPoint } from "./util/IPoint";
import type { IRenderer, IRendererClass } from "./render/backend/Renderer";
import type { Timezone } from "./util/Timezone";
import { Container } from "./render/Container";
import { Text } from "./render/Text";
import { HorizontalLayout } from "./render/HorizontalLayout";
import { VerticalLayout } from "./render/VerticalLayout";
import { GridLayout } from "./render/GridLayout";
import { IDisposer } from "./util/Disposer";
import { InterfaceColors } from "./util/InterfaceColors";
import { Tooltip } from "./render/Tooltip";
import { NumberFormatter } from "./util/NumberFormatter";
import { DateFormatter } from "./util/DateFormatter";
import { DurationFormatter } from "./util/DurationFormatter";
import { ILocale, Language } from "./util/Language";
import { Events, EventDispatcher } from "./util/EventDispatcher";
/**
 * @ignore
 */
interface IParent extends Entity {
    _prepareChildren(): void;
    _updateChildren(): void;
    _childrenUpdt: boolean;
    _childrenPrep: boolean;
}
interface IBounds extends Entity {
    depth(): number;
    _updateBounds(): void;
}
export interface ISize {
    width: number;
    height: number;
}
export interface IRootEvents {
    /**
     * A frame started rendering. `timestamp` is the frame's time in milliseconds.
     */
    framestarted: {
        timestamp: number;
    };
    /**
     * A frame finished rendering. `timestamp` is the frame's time in milliseconds.
     */
    frameended: {
        timestamp: number;
    };
}
export interface IRootSettings {
    /**
     * Draws the chart at a resolution of `1` on iOS and iPadOS devices instead
     * of the screen's pixel ratio, to stay within their memory limits. Set to
     * `false` for sharper charts there.
     *
     * @default true
     */
    useSafeResolution?: boolean;
    /**
     * Extra space in pixels on each side of the chart where tooltips can still
     * be drawn, letting them go outside the chart's container.
     *
     * @since 5.2.24
     */
    tooltipContainerBounds?: {
        top: number;
        left: number;
        right: number;
        bottom: number;
    };
    /**
     * Set to `false` to disable all accessibility features.
     *
     * NOTE: once disabled, accessibility cannot be re-enabled on a live `Root` object.
     *
     * @default true
     * @since 5.3.0
     */
    accessible?: boolean;
    /**
     * If set to `true`, the parent inner `<div>` element will become a focusable
     * element.
     *
     * @since 5.3.17
     * @default false
     * @see {@link https://www.amcharts.com/docs/v5/concepts/accessibility/#Accessibility_of_Root_element} for more info
     */
    focusable?: boolean;
    /**
     * Distance between focused element and its highlight square in pixels.
     *
     * @since 5.6.0
     * @default 2
     */
    focusPadding?: number;
    /**
     * If set to some string, it will be used as inner `<div>` ARIA-LABEL.
     *
     * Should be used in conjunction with `focusable`.
     *
     * @since 5.3.17
     * @see {@link https://www.amcharts.com/docs/v5/concepts/accessibility/#Accessibility_of_Root_element} for more info
     */
    ariaLabel?: string;
    /**
     * Allows setting a "role" for the inner `<div>`.
     *
     * @since 5.3.17
     * @see {@link https://www.amcharts.com/docs/v5/concepts/accessibility/#Accessibility_of_Root_element} for more info
     */
    role?: string;
    /**
     * A function that returns the width and height in pixels to draw the chart
     * at, given the container's measured box. It runs when the chart is created
     * and on every resize.
     */
    calculateSize?: (dimensions: DOMRect) => ISize;
    /**
     * Cleans potentially malicious code out of HTML content (`html` and
     * `labelHTML` settings, HTML tooltips, modals, export menu labels) before
     * it goes on the page.
     *
     * Turn it off only if you trust all HTML content: unsanitized HTML from
     * untrusted data can lead to XSS attacks.
     *
     * @default true
     * @since 5.19.0
     */
    sanitizeHTML?: boolean;
    /**
     * Font family for all labels. It overrides the theme's, but not a
     * `fontFamily` set on a label itself.
     *
     * @since 5.20.2
     */
    fontFamily?: string;
    /**
     * Font size for all labels: a number in pixels, or a CSS size such as
     * `"1.2em"`. It overrides the theme's, but not a `fontSize` set on a label
     * itself.
     *
     * @since 5.20.2
     */
    fontSize?: number | string;
    /**
     * Font weight for all labels. It overrides the theme's, but not a
     * `fontWeight` set on a label itself.
     *
     * @since 5.20.2
     */
    fontWeight?: "normal" | "bold" | "bolder" | "lighter" | "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
    /**
     * The renderer that draws the chart. Defaults to `Root.defaultRenderer`,
     * which is `CanvasRenderer` unless changed.
     *
     * To draw with SVG, use `am5.SVGRenderer`:
     *
     * ```TypeScript
     * const root = am5.Root.new("chartdiv", {
     *   renderer: am5.SVGRenderer
     * });
     * ```
     * ```JavaScript
     * var root = am5.Root.new("chartdiv", {
     *   renderer: am5.SVGRenderer
     * });
     * ```
     *
     * Can only be set when the Root is created.
     *
     * @since 5.21.0
     */
    renderer?: IRendererClass;
    /**
     * Makes the chart's interface colors (labels, grid, axes, buttons) follow
     * the system colors when the page is in a forced colors mode, such as
     * Windows High Contrast, so they stay visible. Series colors are kept.
     *
     * @default true
     * @since 5.21.0
     */
    forcedColors?: boolean;
}
/**
 * The root of a chart: it ties the chart to an HTML element and holds its
 * global settings, formatters, locale and themes.
 *
 * @see {@link https://www.amcharts.com/docs/v5/getting-started/#Root_element} for more info
 */
export declare class Root implements IDisposer {
    /**
     * The HTML element the chart is in.
     */
    dom: HTMLElement;
    _inner: HTMLElement;
    protected _settings: IRootSettings;
    /**
     * Settings the Root filled in for itself, so that serializing can leave them
     * out - a `Root` is not an `Entity`, so it has no `_computedProperties`.
     *
     * @ignore
     */
    _computedSettings: {
        [K in keyof IRootSettings]?: boolean;
    };
    protected _isDirty: boolean;
    protected _isDirtyParents: boolean;
    protected _isDirtyAnimation: boolean;
    protected _dirty: {
        [id: number]: Entity;
    };
    protected _dirtyParents: {
        [id: number]: IParent;
    };
    protected _dirtyBounds: {
        [id: number]: IBounds;
    };
    protected _dirtyPositions: {
        [id: number]: Sprite;
    };
    protected _ticker: ((currentTime: number) => void) | null;
    protected _tickers: Array<(currentTime: number) => void>;
    protected _updateTick: boolean;
    skipRenderFrame: boolean;
    /**
     * Root's event dispatcher.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/events/} for more info
     */
    events: EventDispatcher<Events<this, IRootEvents>>;
    /**
     * Time in milliseconds of the frame being rendered, or `null` while no
     * frames run.
     *
     * @ignore
     */
    animationTime: number | null;
    private _animations;
    _renderer: IRenderer;
    _rootContainer: Container;
    /**
     * The main container: charts and other elements go into its `children`.
     */
    container: Container;
    /**
     * The [[Container]] tooltips are drawn in, above the chart.
     */
    tooltipContainer: Container;
    protected _tooltipContainerSettings: {
        top: number;
        left: number;
        right: number;
        bottom: number;
    };
    _tooltip: Tooltip;
    /**
     * @ignore
     */
    language: Language;
    /**
     * Locale for the chart's texts and formatting. English by default.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/locales/}
     */
    locale: ILocale;
    /**
     * Treats dates as UTC instead of the user's local time, when formatting
     * and parsing them and when placing date axis grid. It takes precedence
     * over `timezone`.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/formatters/formatting-dates/#utc-and-time-zones} for more info
     */
    utc: boolean;
    /**
     * Time zone to show dates in, instead of the user's local one. Set it to a
     * [[Timezone]] with an IANA name, e.g.
     * `am5.Timezone.new("America/Vancouver")`. For UTC, `utc` is faster.
     *
     * Every date is converted, which can slow down charts with large data sets.
     *
     * @see {@link https://www.amcharts.com/docs/v5/getting-started/root-element/#time-zone} for more info
     * @since 5.1.0
     */
    timezone?: Timezone;
    /**
     * Maximum frames per second. When not set, the chart renders on every
     * animation frame of the browser.
     *
     * Each frame waits `1000 / fps` milliseconds after the previous one is
     * drawn, then for the screen's next refresh, so the rate achieved is lower:
     * `fps: 30` gives about 20 on a 60 Hz screen.
     *
     * @see {@link https://www.amcharts.com/docs/v5/getting-started/root-element/#Performance} for more info
     */
    fps: number | undefined;
    /**
     * Number formatter.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/formatters/formatting-numbers/} for more info
     */
    numberFormatter: NumberFormatter;
    /**
     * Date/time formatter.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/formatters/formatting-dates/} for more info
     */
    dateFormatter: DateFormatter;
    /**
     * Duration formatter.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/formatters/formatting-dates/} for more info
     */
    durationFormatter: DurationFormatter;
    /**
     * Tab index for the whole chart.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/accessibility/} for more info
     */
    tabindex: number;
    protected _tabindexes: Sprite[];
    protected _a11yD: boolean;
    protected _focusElementDirty: boolean;
    protected _focusElementContainer: HTMLDivElement | undefined;
    protected _focusedSprite: Sprite | undefined;
    protected _isShift: boolean | undefined;
    protected _keyboardDragPoint: IPoint | undefined;
    protected _tooltipElementContainer: HTMLDivElement | undefined;
    protected _readerAlertElement: HTMLDivElement | undefined;
    protected _groupStops: {
        [group: string]: Sprite;
    };
    protected _dirtyGroups: {
        [group: string]: string | number;
    };
    _logo?: Container;
    _tooltipDiv: HTMLDivElement | undefined;
    /**
     * Nonce for the `<style>` elements the chart adds to the page, for pages
     * with a strict Content Security Policy.
     */
    nonce?: string;
    /**
     * Colors of the chart's interface: text, grid, buttons and other controls.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/colors-gradients-and-patterns/#Interface_colors} for more info
     */
    interfaceColors: InterfaceColors;
    /**
     * A shared [[VerticalLayout]] for a [[Container]]'s `layout` setting.
     *
     * @default VerticalLayout.new()
     */
    verticalLayout: VerticalLayout;
    /**
     * A shared [[HorizontalLayout]] for a [[Container]]'s `layout` setting.
     *
     * @default HorizontalLayout.new()
     */
    horizontalLayout: HorizontalLayout;
    /**
     * A shared [[GridLayout]] for a [[Container]]'s `layout` setting.
     *
     * @default GridLayout.new()
     */
    gridLayout: GridLayout;
    _paused: boolean;
    /**
     * Resizes the chart automatically when its container's size changes. With
     * `false`, call `resize()` to resize it.
     */
    autoResize: boolean;
    protected _fontHash: string;
    protected _styles?: CSSStyleDeclaration;
    protected _isDisposed: boolean;
    protected _disposers: Array<IDisposer>;
    protected _resizeSensorDisposer?: IDisposer;
    _tooltips: Array<Tooltip>;
    protected _htmlElementContainer: HTMLDivElement | undefined;
    protected _htmlEnabledContainers: Container[];
    /**
     * Objects of this root that have an `id` setting, by that `id`.
     *
     * @since 5.11.0
     */
    entitiesById: {
        [index: string]: any;
    };
    protected _systemTooltip: Tooltip;
    protected constructor(id: string | HTMLElement, settings: IRootSettings | undefined, isReal: boolean);
    /**
     * Renderer for Roots that do not set `renderer`.
     *
     * @default CanvasRenderer
     * @since 5.21.0
     */
    static defaultRenderer: IRendererClass;
    /**
     * Creates a Root in an HTML element. An element can hold only one Root:
     * creating another one there throws an error, unless
     * `am5.registry.autoDispose` is `true`.
     *
     * @param   id        The element, or its `id`
     * @param   settings  Settings
     * @return            Root
     */
    static new(id: string | HTMLElement, settings?: IRootSettings): Root;
    protected static _getDOM(id: string | HTMLElement): HTMLElement;
    /**
     * Moves the chart to another HTML element and resizes it to fit there.
     * Nothing happens if no element with that `id` exists.
     *
     * @param  id  The element, or its `id`
     */
    moveDOM(id: string | HTMLElement): void;
    protected _handleLogo(): void;
    _showBranding(): void;
    protected _getRealSize(): DOMRect;
    protected _getCalculatedSize(rect: DOMRect): ISize;
    protected _init(): void;
    /**
     * A shared [[Tooltip]] (theme tag `"system"`) for interface elements such
     * as the logo and buttons, created on first use.
     * @since 5.14.0
     */
    get systemTooltip(): Tooltip;
    private _initResizeSensor;
    /**
     * Resizes the chart to fit its container. Call it after the container's
     * size changes when `autoResize` is `false`.
     */
    resize(): void;
    /**
     * Re-applies the current `_settings` to the live `Root` and its sub-objects
     * without tearing anything down.
     *
     * Unlike `_init()`, this creates no new containers, DOM elements, or event
     * listeners. Use it after changing settings on an already-initialized `Root`
     * (e.g. from a parsed `root` config section).
     *
     * NOTE: `accessible` can only be turned off (matching constructor behavior);
     * it cannot be re-enabled on a live `Root`.
     *
     * @ignore
     */
    _reapplySettings(): void;
    /**
     * The Root's settings.
     */
    get settings(): IRootSettings;
    private _render;
    private _runTickers;
    private _runAnimations;
    private _runDirties;
    private _renderFrame;
    _runTicker(currentTime: number, now?: boolean): void;
    _runTickerNow(timeout?: number): void;
    private _startTicker;
    /**
     * Whether the chart updates and redraws.
     */
    get updateTick(): boolean;
    /**
     * Stops the chart from updating and redrawing with `false`, until set back
     * to `true`.
     */
    set updateTick(value: boolean);
    _addDirtyEntity(entity: Entity): void;
    _addDirtyParent(parent: IParent): void;
    _addDirtyBounds(entity: IBounds): void;
    _addDirtyPosition(sprite: Sprite): void;
    _addAnimation(animation: IAnimation): void;
    _markDirty(): void;
    _markDirtyRedraw(): void;
    /**
     * Calls a function on every frame, which keeps the chart rendering, until
     * the returned disposer is disposed.
     *
     * @param   f  Function, given the frame's time in milliseconds
     * @return     Disposer that stops the calls
     */
    eachFrame(f: (currentTime: number) => void): IDisposer;
    /**
     * Makes every element inside a container update and re-measure on the next
     * frame.
     *
     * @param  container  Container; the main `container` if not given
     */
    markDirtyGlobal(container?: Container): void;
    /**
     * Returns the chart's width in pixels: the container's, or the one from
     * `calculateSize` if set.
     *
     * @return Width
     */
    width(): number;
    /**
     * Returns the chart's height in pixels: the container's, or the one from
     * `calculateSize` if set.
     *
     * @return Height
     */
    height(): number;
    /**
     * Disposes the Root and everything in it, and removes the chart from the
     * page.
     */
    dispose(): void;
    /**
     * Returns `true` if the Root is disposed.
     *
     * @return Disposed?
     */
    isDisposed(): boolean;
    /**
     * Makes screen readers read out a message.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/accessibility/} for more info
     * @param  text  Alert text
     */
    readerAlert(text: string): void;
    /**
     * Sets the chart's themes, replacing any set before.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/themes/} for more info
     * @param  themes  A list of themes
     */
    setThemes(themes: Array<Theme>): void;
    protected _addTooltip(): void;
    /**
     * Accessibility
     */
    _registerTabindexOrder(target: Sprite): void;
    _unregisterTabindexOrder(target: Sprite): void;
    _invalidateTabindexes(): void;
    _canFocus(target: Sprite): boolean;
    _canTab(target: Sprite): boolean;
    protected _invalidateGroup(group: string | number): void;
    protected _updateDirtyGroups(): void;
    protected _updateGroup(group: string | number): void;
    _updateCurrentFocus(): void;
    _decorateFocusElement(target: Sprite, focusElement?: HTMLDivElement): void;
    protected _forcedColorsBackup?: {
        [key: string]: {
            value: any;
            user: boolean;
        };
    };
    protected _initForcedColors(): void;
    /**
     * Applies or removes system interface colors for a forced colors mode.
     *
     * @ignore
     */
    _updateForcedColors(): void;
    protected _stopKeyboardDrag(target: Sprite): void;
    _hasFocusSize(target: Sprite): boolean;
    _makeFocusElement(index: number, target: Sprite): void;
    _removeFocusElement(target: Sprite): void;
    _hideFocusElement(target: Sprite): void;
    protected _moveFocusElement(index: number, target: Sprite): void;
    protected _positionFocusElement(target: Sprite): void;
    protected _getSpriteByFocusElement(target: any): Sprite | undefined;
    protected _handleFocus(ev: FocusEvent): void;
    protected _focusNext(el: HTMLDivElement, direction: 1 | -1, group?: string | number): void;
    protected _handleBlur(ev: FocusEvent): void;
    /**
     * @ignore
     */
    updateTooltip(target: Text): void;
    _makeTooltipElement(target: Text): HTMLDivElement;
    _removeTooltipElement(target: Text): void;
    _invalidateAccessibility(target: Sprite): void;
    /**
     * Returns `true` if `target` is currently focused.
     *
     * @param   target  Target
     * @return          Focused?
     */
    focused(target: Sprite): boolean;
    /**
     * Converts a point from viewport coordinates, such as a pointer event's
     * `clientX` and `clientY`, to coordinates within the root.
     *
     * @param   point  Viewport point
     * @return         Root point
     */
    documentPointToRoot(point: IPoint): IPoint;
    /**
     * Converts a point from coordinates within the root to viewport
     * coordinates, as in a pointer event's `clientX` and `clientY`.
     *
     * @param   point  Root point
     * @return         Viewport point
     */
    rootPointToDocument(point: IPoint): IPoint;
    /**
     * @ignore
     */
    addDisposer<T extends IDisposer>(disposer: T): T;
    protected _updateComputedStyles(): boolean;
    protected _checkComputedStyles(): void;
    protected _invalidateLabelBounds(target: Sprite, remeasure?: boolean): void;
    /**
     * To all the clever heads out there. Yes, we did not make any attempts to
     * scramble this.
     *
     * This is a part of a tool meant for our users to manage their commercial
     * licenses for removal of amCharts branding from charts.
     *
     * The only legit way to do so is to purchase a commercial license for amCharts:
     * https://www.amcharts.com/online-store/
     *
     * Removing or altering this code, or disabling amCharts branding in any other
     * way is against the license and thus illegal.
     */
    protected _hasLicense(): boolean;
    _licenseApplied(): void;
    /**
     * @ignore
     */
    get debugGhostView(): boolean;
    /**
     * @ignore
     */
    set debugGhostView(value: boolean);
    /**
     * Makes touch gestures such as zoom and pan work only after a tap on the
     * chart, so the page can still be scrolled over it.
     *
     * @see {@link https://www.amcharts.com/docs/v5/getting-started/root-element/#Touch_related_options} for more info
     * @default false
     * @since 5.2.9
     * @param  value  Needs a tap to activate touch functions
     */
    set tapToActivate(value: boolean);
    /**
     * @return Needs a tap to activate touch functions
     */
    get tapToActivate(): boolean;
    /**
     * How long in milliseconds the chart stays active after the last touch,
     * with `tapToActivate`, before handing touch gestures back to the page.
     * `0` keeps it active until a tap outside the chart.
     *
     * @see {@link https://www.amcharts.com/docs/v5/getting-started/root-element/#Touch_related_options} for more info
     * @default 3000
     * @since 5.2.9
     * @param  value  Timeout
     */
    set tapToActivateTimeout(value: number);
    /**
     * @return Timeout
     */
    get tapToActivateTimeout(): number;
    _makeHTMLElement(target: Container): HTMLDivElement;
    _positionHTMLElements(): void;
    _positionHTMLElement(target: Container): void;
    /**
     * Sanitizes HTML content before it gets injected via `innerHTML`, unless
     * sanitization is disabled via the `sanitizeHTML` setting.
     *
     * @ignore
     */
    _sanitizeHTML(html: string): string;
    _setHTMLContent(target: Container, html: string): void;
    _removeHTMLContent(target: Container): void;
}
export {};
//# sourceMappingURL=Root.d.ts.map