import { Plane3D, Vector3D, AbstractionBase, AssetEvent, Matrix3D, ColorTransform, Point } from '@awayjs/core';
import { IPartitionTraverser } from './IPartitionTraverser';
import { INode } from './INode';
import { PickGroup } from '../PickGroup';
import { HierarchicalProperty } from '../base/HierarchicalProperty';
import { IContainer } from '../base/IContainer';
import { View } from '../View';
export declare class ContainerNode extends AbstractionBase implements INode {
    private static _nullTransform;
    private static _tempVector3D;
    private static _nullColorTransform;
    private _invalidateMatrix3DEvent;
    private _invalidateColorTransformEvent;
    private _localNode;
    private _pickObject;
    private _pickObjectNode;
    private _scrollRect;
    private _scrollRectNode;
    private _renderToImage;
    private _isDragEntity;
    private _position;
    private _positionDirty;
    private _scale9Container;
    private _matrix3D;
    private _colorTransform;
    private _inverseMatrix3D;
    private _inverseMatrix3DDirty;
    private _orientationMatrix;
    private _maskDisabled;
    private _colorTransformDisabled;
    private _transformDisabled;
    private _activeTransform;
    private _invisible;
    private _maskId;
    private _mouseChildrenDisabled;
    private _maskOwners;
    private _masks;
    protected _parent: ContainerNode;
    protected _childNodes: Array<ContainerNode>;
    protected _numChildNodes: number;
    _hierarchicalPropsDirty: HierarchicalProperty;
    _collectionMark: number;
    get parent(): ContainerNode;
    get numChildNodes(): number;
    get container(): IContainer;
    get pickObjectNode(): ContainerNode;
    get renderToImage(): boolean;
    get boundsVisible(): boolean;
    get view(): View;
    /**
     * Allow disable/enable colorTransform for this node independent of transform, this required for cache phase
     * @param value
     */
    set colorTransformDisabled(value: boolean);
    get colorTransformDisabled(): boolean;
    set maskDisabled(value: boolean);
    get maskDisabled(): boolean;
    set transformDisabled(value: boolean);
    get transformDisabled(): boolean;
    getScale9Container(): IContainer;
    /**
     *
     */
    getPosition(): Vector3D;
    /**
     *
     */
    getInverseMatrix3D(): Matrix3D;
    getMatrix3D(): Matrix3D;
    /**
     *
     */
    getRenderMatrix3D(cameraTransform: Matrix3D): Matrix3D;
    getColorTransform(): ColorTransform;
    /**
     *
     * @returns {number}
     */
    getMaskId(): number;
    getMasks(update?: boolean): ContainerNode[];
    getMaskOwners(): ContainerNode[];
    /**
     * Converts the `point` object from the Stage(global) coordinates to the
     * display object's(local) coordinates.
     *
     * To use this method, first create an instance of the Point class. The _x_
     * and _y_ values that you assign represent global coordinates because they
     * relate to the origin(0,0) of the main display area. Then pass the Point
     * instance as the parameter to the `globalToLocal()` method. The method
     * returns a new Point object with _x_ and _y_ values that relate to the
     * origin of the display object instead of the origin of the Stage.
     *
     */
    globalToLocal(point: Point, target?: Point): Point;
    /**
     * Converts a two-dimensional point from the Scene(global) coordinates to a
     * three-dimensional display object's(local) coordinates.
     *
     * <p>To use this method, first create an instance of the Vector3D class. The x,
     * y and z values that you assign to the Vector3D object represent global
     * coordinates because they are relative to the origin(0,0,0) of the scene. Then
     * pass the Vector3D object to the <code>globalToLocal3D()</code> method as the
     * <code>position</code> parameter.
     * The method returns three-dimensional coordinates as a Vector3D object
     * containing <code>x</code>, <code>y</code>, and <code>z</code> values that
     * are relative to the origin of the three-dimensional display object.</p>
     *
     */
    globalToLocal3D(position: Vector3D): Vector3D;
    /**
     * Converts the `point` object from the display object's(local) coordinates
     * to the Stage(global) coordinates.
     *
     * This method allows you to convert any given _x_ and _y_ coordinates from
     * values that are relative to the origin(0,0) of a specific display
     * object(local coordinates) to values that are relative to the origin of
     * the Stage(global coordinates).
     *
     * To use this method, first create an instance of the Point class. The _x_
     * and _y_ values that you assign represent local coordinates because they
     * relate to the origin of the display object.
     *
     * You then pass the Point instance that you created as the parameter to the
     * `localToGlobal()` method. The method returns a new Point object with _x_
     * and _y_ values that relate to the origin of the Stage instead of the
     * origin of the display object.
     *
     * @param point The name or identifier of a point created with the Point
     *              class, specifying the _x_ and _y_ coordinates as properties.
     * @param target Result point
     * @return A Point object with coordinates relative to the Stage.
     */
    localToGlobal(point: Point, target?: Point): Point;
    getBoundsPrimitive(_pickGroup: PickGroup): ContainerNode;
    init(container: IContainer, pool: View): void;
    getLocalNode(): ContainerNode;
    clearLocalNode(): void;
    onClear(event: AssetEvent): void;
    onInvalidate(event: AssetEvent): void;
    clear(): void;
    isInFrustum(_rootEntity: INode, _planes: Array<Plane3D>, _numPlanes: number, _pickGroup: PickGroup): boolean;
    invalidate(): void;
    /**
     * @internal
     */
    isInvisible(): boolean;
    isIntersectingRay(_rootEntity: INode, _rayPosition: Vector3D, _rayDirection: Vector3D, _pickGroup: PickGroup): boolean;
    /**
     *
     * @returns {boolean}
     */
    isRenderable(): boolean;
    /**
     *
     * @returns {boolean}
     */
    isCastingShadow(): boolean;
    /**
     * @param traverser
     */
    acceptTraverser(traverser: IPartitionTraverser): void;
    addChildAt(entity: IContainer, index: number): ContainerNode;
    removeChildAt(index: number): ContainerNode;
    getChildAt(index: number): ContainerNode;
    startDrag(): void;
    stopDrag(): void;
    isDragEntity(): boolean;
    isMouseDisabled(): boolean;
    isMouseChildrenDisabled(): boolean;
    isDescendant(node: INode): boolean;
    invalidateHierarchicalProperty(property: HierarchicalProperty): void;
    setParent(parent: ContainerNode): void;
}
//# sourceMappingURL=ContainerNode.d.ts.map