/** @ignore */ /** */
import type { IMargin, ILayer, ICanvasOptions, IPointerEvent } from "./Renderer";
import type { ISceneHost } from "../scene/SceneNode";
import type { ISvgItem } from "./SvgExport";
import type { IBounds } from "../../util/IBounds";
import type { IPoint } from "../../util/IPoint";
import { CanvasRendererEvent } from "./CanvasRenderer";
import { SvgDefs } from "./SvgExport";
import { LinearGradientDef, RadialGradientDef, PatternDef, RasterPatternDef } from "../scene/Paint";
import { InteractionManager } from "../scene/Interaction";
import { GeometricHitTester } from "../scene/HitTest";
import { SceneNode, SceneContainer, SceneGraphics, SceneText, SceneTextStyle, SceneRadialText, SceneImage } from "../scene/SceneNode";
import { ArrayDisposer } from "../../util/Disposer";
/**
 * A node's elements and the markup they were made from.
 *
 * @ignore
 */
interface ILeafState {
    markup: string;
    elements: Array<Element>;
}
/**
 * @ignore
 */
interface IClipState {
    clip: string;
    element: SVGGElement;
}
/**
 * @ignore
 */
export declare class SvgLayer implements ILayer {
    element: SVGSVGElement;
    order: number;
    visible: boolean;
    width: number | undefined;
    height: number | undefined;
    dirty: boolean;
    margin: IMargin | undefined;
    _canvas: HTMLCanvasElement | undefined;
    _defs: SvgDefs;
    _defsElement: SVGDefsElement;
    _defElements: Map<string, Element>;
    _content: SVGGElement;
    _leaves: Map<SceneNode, ILeafState>;
    _clips: Map<SceneNode, IClipState>;
    /**
     * `element` is a viewport that clips like the layer's canvas: the chart's
     * size plus the layer's margin.
     */
    constructor(element: SVGSVGElement, idPrefix: string);
    resize(width: number, height: number): void;
}
/**
 * Draws charts as a live SVG document instead of canvases.
 *
 * ```TypeScript
 * const root = am5.Root.new("chartdiv", {
 *   renderer: am5.SVGRenderer
 * });
 * ```
 * ```JavaScript
 * var root = am5.Root.new("chartdiv", {
 *   renderer: am5.SVGRenderer
 * });
 * ```
 *
 * All layers are in one `<svg>` element. Hit testing is geometric (no
 * hidden canvas); text is measured with an in-page canvas, so it wraps and
 * truncates exactly as with `CanvasRenderer`. Image export paints the same
 * scene with an offscreen `CanvasRenderer`.
 *
 * Blend modes `DST_OVER`, `SRC_ATOP` and `XOR` are canvas-only: SVG draws
 * them as `NORMAL`.
 *
 * @see {@link https://www.amcharts.com/docs/v5/getting-started/root-element/#renderer} for more information
 * @since 5.21.0
 */
export declare class SVGRenderer extends ArrayDisposer implements ISceneHost {
    /**
     * @ignore
     */
    view: HTMLElement;
    /**
     * @ignore
     */
    _svg: SVGSVGElement;
    protected _id: number;
    protected _realWidth: number;
    protected _realHeight: number;
    protected _calculatedWidth: number;
    protected _calculatedHeight: number;
    /**
     * @ignore
     */
    layers: Array<SvgLayer>;
    /**
     * @ignore
     */
    defaultLayer: SvgLayer;
    /**
     * @ignore
     */
    resolution: number;
    /**
     * @ignore
     */
    _interaction: InteractionManager<SceneNode>;
    protected _hitTester: GeometricHitTester;
    protected _root: SceneNode | undefined;
    protected _measureCanvas: HTMLCanvasElement;
    protected _measureContext: CanvasRenderingContext2D;
    protected _parser: SVGGElement;
    /**
     * @ignore
     */
    constructor(resolution?: number);
    /**
     * @ignore
     */
    get interactionsEnabled(): boolean;
    /**
     * @ignore
     */
    set interactionsEnabled(value: boolean);
    /**
     * @ignore
     */
    get tapToActivate(): boolean;
    /**
     * @ignore
     */
    set tapToActivate(value: boolean);
    /**
     * @ignore
     */
    get tapToActivateTimeout(): number;
    /**
     * @ignore
     */
    set tapToActivateTimeout(value: number);
    /**
     * There is no ghost canvas: hit testing is geometric.
     * @ignore
     */
    get debugGhostView(): boolean;
    /**
     * @ignore
     */
    set debugGhostView(_value: boolean);
    /**
     * @ignore
     */
    createLinearGradient(x1: number, y1: number, x2: number, y2: number): LinearGradientDef;
    /**
     * @ignore
     */
    createRadialGradient(x1: number, y1: number, radius1: number, x2: number, y2: number, radius2: number): RadialGradientDef;
    /**
     * @ignore
     */
    createPattern(graphics: SceneGraphics, background: SceneGraphics, repetition: string, width: number, height: number): PatternDef;
    /**
     * A detached copy of graphics as they are now.
     */
    protected _snapshot(graphics: SceneGraphics): SceneGraphics;
    /**
     * @ignore
     */
    createRasterPattern(source: HTMLCanvasElement, repetition: string): RasterPatternDef | null;
    /**
     * @ignore
     */
    makeContainer(): SceneContainer;
    /**
     * @ignore
     */
    makeGraphics(): SceneGraphics;
    /**
     * @ignore
     */
    makeText(text: string, style: SceneTextStyle): SceneText;
    /**
     * @ignore
     */
    makeTextStyle(): SceneTextStyle;
    /**
     * @ignore
     */
    makeRadialText(text: string, style: SceneTextStyle): SceneRadialText;
    /**
     * @ignore
     */
    makePicture(image: HTMLImageElement | undefined): SceneImage;
    /**
     * @ignore
     */
    resize(realWidth: number, realHeight: number, calculatedWidth: number, calculatedHeight: number): void;
    /**
     * @ignore
     */
    getLayerByOrder(order: number): SvgLayer | undefined;
    /**
     * @ignore
     */
    getLayer(order: number, visible?: boolean): SvgLayer;
    protected _applyVisible(layer: SvgLayer): void;
    /**
     * @ignore
     */
    render(root: SceneNode): void;
    /**
     * Brings a layer's DOM up to date. Elements whose markup did not change
     * are kept; changed ones are parsed together and put in place.
     */
    protected _renderLayer(root: SceneNode, layer: SvgLayer): void;
    /**
     * Pairs items with last frame's elements: leaves by markup, clip groups
     * by node. Leaves that need new elements go to `parse`.
     */
    protected _match(layer: SvgLayer, items: Array<ISvgItem>, leaves: Map<SceneNode, ILeafState>, clips: Map<SceneNode, IClipState>, parse: Array<ILeafState>): void;
    /**
     * Puts the elements of `items` into `parent` in order, moving only those
     * that are out of place.
     */
    protected _place(parent: Element, items: Array<ISvgItem>, leaves: Map<SceneNode, ILeafState>, clips: Map<SceneNode, IClipState>): void;
    /**
     * Adds defs used this frame, removes the rest.
     */
    protected _syncDefs(layer: SvgLayer): void;
    /**
     * Parses markup snippets, one top-level element each, in one go.
     */
    protected _parse(snippets: Array<string>): Array<Element>;
    /**
     * @ignore
     */
    _removeObject(_node: SceneNode): void;
    /**
     * @ignore
     */
    _useLayer(order: number, margin: IMargin | undefined): SvgLayer;
    /**
     * A transparent canvas over the layer, for code that needs a raster
     * element to position against (the annotator). It holds no pixels of
     * the chart.
     * @ignore
     */
    _layerCanvas(layer: ILayer): HTMLCanvasElement;
    protected _resizeCanvas(layer: SvgLayer): void;
    /**
     * Lays text out with the in-page measuring canvas, in the state the canvas
     * renderer measures with.
     * @ignore
     */
    _measureText(text: SceneText): IBounds;
    protected _margin(): IMargin;
    /**
     * @ignore
     */
    getEvent<A extends IPointerEvent>(originalEvent: A, adjustPoint?: boolean): CanvasRendererEvent<A>;
    /**
     * @ignore
     */
    _getHitTarget(point: IPoint, bbox: DOMRect, target: Node | null): SceneNode | undefined | false;
    protected _hitTest(point: IPoint): SceneNode | undefined;
    /**
     * @ignore
     */
    getObjectAtPoint(point: IPoint): SceneNode | undefined;
    /**
     * @ignore
     */
    removeHovering(graphics: SceneNode): void;
    /**
     * @ignore
     */
    resetImageArray(): void;
    /**
     * The chart as an image: the same scene painted by an offscreen
     * `CanvasRenderer`, so image export looks as it does with canvas.
     * @ignore
     */
    getCanvas(root: SceneNode, options?: ICanvasOptions): HTMLCanvasElement;
}
export {};
//# sourceMappingURL=SVGRenderer.d.ts.map