/** @ignore */ /** */
import type { IDeform, IContainer, IDisplayObject, IGraphics, IText, IRadialText, IPicture, IRenderer, IRendererEvents, IMargin, ITextStyle, ILayer, IGradient, IPattern } from "../backend/Renderer";
import type { IBounds } from "../../util/IBounds";
import type { IPoint } from "../../util/IPoint";
import type { ILine, ILineChunk, ITextLayoutState } from "./TextLayout";
import type { InteractionManager } from "./Interaction";
import { BlendMode } from "../backend/Renderer";
import { GraphicsData } from "./GraphicsData";
import { Color } from "../../util/Color";
import { Matrix } from "../../util/Matrix";
import { Percent } from "../../util/Percent";
import { DisposerClass, IDisposer } from "../../util/Disposer";
/**
 * What scene nodes need from the renderer that owns them.
 *
 * @ignore
 */
export interface ISceneHost extends IRenderer {
    readonly defaultLayer: ILayer;
    readonly layers: ReadonlyArray<ILayer>;
    readonly _interaction: InteractionManager<SceneNode>;
    /**
     * The layer for `order`, created if needed, marked dirty and sized.
     */
    _useLayer(order: number, margin: IMargin | undefined): ILayer;
    /**
     * The canvas a layer paints on, for code that needs a raster element.
     */
    _layerCanvas(layer: ILayer): HTMLCanvasElement;
    /**
     * Lays out `text` and returns its local bounds.
     */
    _measureText(text: SceneText): IBounds;
    _removeObject(node: SceneNode): void;
}
export declare class ScenePivot implements IPoint {
    protected _x: number;
    protected _y: number;
    get x(): number;
    get y(): number;
    set x(value: number);
    set y(value: number);
}
/**
 * A renderer-neutral display object: state, place in the tree, transform and
 * bounds. Backends paint it.
 *
 * @ignore
 */
export declare class SceneNode extends DisposerClass implements IDisplayObject, IDisposer {
    _layer?: ILayer;
    mask: SceneGraphics | null;
    visible: boolean;
    exportable?: boolean;
    interactive: boolean;
    inactive: boolean | null;
    wheelable: boolean;
    cancelTouch: boolean;
    isMeasured: boolean;
    buttonMode: boolean;
    alpha: number;
    compoundAlpha: number;
    angle: number;
    scale: number;
    x: number;
    y: number;
    crisp: boolean;
    pivot: ScenePivot;
    /**
     * A 2x2 transform applied around the node's position after its rotation
     * and scale, e.g. to lay a map bullet onto the projected surface. `null`
     * (the default) leaves the transform as it was.
     *
     * @ignore
     */
    deform: IDeform | null;
    filter?: string;
    cursorOverStyle?: string;
    _replacedCursorStyle?: string;
    _localMatrix: Matrix;
    _matrix: Matrix;
    protected _uMatrix: Matrix;
    protected _mx: number;
    protected _my: number;
    protected _mpx: number;
    protected _mpy: number;
    protected _mAngle: number;
    protected _mScale: number;
    protected _mDeform: IDeform | null;
    _renderer: ISceneHost;
    _parent: SceneContainer | undefined;
    _localBounds: IBounds | undefined;
    protected _bounds: IBounds | undefined;
    _colorId: string | undefined;
    constructor(renderer: ISceneHost);
    protected _dispose(): void;
    getCanvas(): HTMLCanvasElement;
    getLayer(): ILayer;
    setLayer(order: number | undefined, margin: IMargin | undefined): void;
    markDirtyLayer(): void;
    clear(): void;
    invalidateBounds(): void;
    _addBounds(_bounds: IBounds): void;
    contains(child: SceneNode): boolean;
    toGlobal(point: IPoint): IPoint;
    toLocal(point: IPoint): IPoint;
    getLocalMatrix(): Matrix;
    getLocalBounds(): IBounds;
    getContentBounds(): IBounds;
    getAdjustedBounds(bounds: IBounds): IBounds;
    on<C, Key extends keyof IRendererEvents>(key: Key, callback: (this: C, event: IRendererEvents[Key]) => void, context?: C): IDisposer;
    _setMatrix(): void;
    hovering(): boolean;
    dragging(): boolean;
    shouldCancelTouch(): boolean;
}
/**
 * @ignore
 */
export declare class SceneContainer extends SceneNode implements IContainer {
    interactiveChildren: boolean;
    private _childLayers?;
    _children: Array<SceneNode>;
    addChild(child: SceneNode): void;
    addChildAt(child: SceneNode, index: number): void;
    removeChild(child: SceneNode): void;
    registerChildLayer(layer: ILayer): void;
    markDirtyLayer(deep?: boolean): void;
    protected _dispose(): void;
}
/**
 * @ignore
 */
export declare class SceneGraphics extends SceneNode implements IGraphics {
    _data: GraphicsData;
    blendMode: BlendMode;
    protected _contentBounds: IBounds | undefined;
    clear(): void;
    getContentBounds(): IBounds;
    beginFill(color?: Color | IGradient | IPattern, alpha?: number): void;
    endFill(): void;
    endStroke(): void;
    beginPath(): void;
    lineStyle(width?: number, color?: Color | IGradient | IPattern, alpha?: number, lineJoin?: "miter" | "round" | "bevel", lineCap?: "butt" | "round" | "square"): void;
    setLineDash(dash?: number[]): void;
    setLineDashOffset(dashOffset?: number): void;
    drawRect(x: number, y: number, width: number, height: number): void;
    drawCircle(x: number, y: number, radius: number): void;
    drawEllipse(x: number, y: number, radiusX: number, radiusY: number): void;
    arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
    lineTo(x: number, y: number): void;
    moveTo(x: number, y: number): void;
    bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): void;
    quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): void;
    closePath(): void;
    shadow(color: Color, blur?: number, offsetX?: number, offsetY?: number, opacity?: number): void;
    image(image: HTMLImageElement | HTMLCanvasElement, width: number, height: number, x: number, y: number): void;
    svgPath(path: string): void;
    beginGroup(id?: string, name?: string): void;
    endGroup(): void;
    _addBounds(bounds: IBounds): void;
}
/**
 * @ignore
 */
export declare class SceneTextStyle implements ITextStyle {
    fill?: Color | IGradient | IPattern;
    fillOpacity?: number;
    textAlign?: "start" | "end" | "left" | "right" | "center";
    fontFamily?: string;
    fontSize?: string | number;
    fontWeight?: 'normal' | 'bold' | 'bolder' | 'lighter' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
    fontStyle?: 'normal' | 'italic' | 'oblique';
    fontVariant?: "normal" | "small-caps";
    textDecoration?: "underline" | "line-through";
    shadowColor?: Color | null;
    shadowBlur?: number;
    shadowOffsetX?: number;
    shadowOffsetY?: number;
    shadowOpacity?: number;
    lineHeight?: number | Percent;
    baselineRatio?: number;
    direction?: "ltr" | "rtl";
    textBaseline?: "top" | "hanging" | "middle" | "alphabetic" | "ideographic" | "bottom";
    oversizedBehavior?: "none" | "hide" | "fit" | "wrap" | "wrap-no-break" | "truncate";
    breakWords?: boolean;
    ellipsis?: string;
    maxWidth?: number;
    maxHeight?: number;
    minScale?: number;
    ignoreFormatting?: boolean;
}
/**
 * Text and its layout. The backend lays it out (`_measureText`) because
 * measuring needs a text engine.
 *
 * @ignore
 */
export declare class SceneText extends SceneNode implements IText {
    text: string;
    style: SceneTextStyle;
    resolution: number;
    textVisible: boolean;
    truncated?: boolean;
    _textInfo: Array<ILine> | undefined;
    protected _originalScale?: number;
    _textBounds: IBounds | undefined;
    constructor(renderer: ISceneHost, text: string, style: SceneTextStyle);
    invalidateBounds(): void;
    invalidateVisibility(): void;
    _getFontStyle(style2?: ITextStyle, ignoreFontWeight?: boolean): string;
    _addBounds(bounds: IBounds): void;
    _layoutState(): ITextLayoutState;
    _applyLayoutState(state: ITextLayoutState): void;
}
/**
 * @ignore
 */
export declare class SceneRadialText extends SceneText implements IRadialText {
    textType?: "regular" | "circular" | "radial" | "aligned" | "adjusted";
    radius?: number;
    startAngle?: number;
    inside?: boolean;
    orientation?: "inward" | "outward" | "auto";
    kerning?: number;
    _textReversed: boolean;
    /**
     * Whether laid-out circular text reads inward. Does not depend on line
     * order, so it holds before and after `_orient()`.
     */
    _inward(): boolean;
    /**
     * Puts lines and glyphs in drawing order, once per layout, and returns
     * whether the text reads inward. Painters call it before drawing.
     */
    _orient(): boolean;
    /**
     * Calls `f` for every glyph with its rotation and baseline offset, as the
     * canvas painter places them.
     */
    _eachGlyph(inward: boolean, f: (chunk: ILineChunk, angle: number, y: number, height: number) => void): void;
}
/**
 * @ignore
 */
export declare class SceneImage extends SceneNode implements IPicture {
    width: number | undefined;
    height: number | undefined;
    image: HTMLImageElement | undefined;
    tainted?: boolean;
    shadowColor?: Color;
    shadowBlur?: number;
    shadowOffsetX?: number;
    shadowOffsetY?: number;
    shadowOpacity?: number;
    _imageMask: HTMLCanvasElement | undefined;
    constructor(renderer: ISceneHost, image: HTMLImageElement | undefined);
    getLocalBounds(): IBounds;
    clear(): void;
}
//# sourceMappingURL=SceneNode.d.ts.map