/**
 * Axis-Aligned bounding box in 3D
 * NOTE: In cases where all you want is raw performance - prefer to use typed arrays instead along with `aabb3_` functions
 * @extends {ArrayLike.<number>}
 */
export class AABB3 {
    /**
     *
     * @param {number} [x0]
     * @param {number} [y0]
     * @param {number} [z0]
     * @param {number} [x1]
     * @param {number} [y1]
     * @param {number} [z1]
     * @constructor
     */
    constructor(x0?: number, y0?: number, z0?: number, x1?: number, y1?: number, z1?: number);
    /**
     *
     * @param {number} v
     */
    set 0(arg: number);
    /**
     *
     * @returns {number}
     */
    get 0(): number;
    /**
     *
     * @param {number} v
     */
    set 1(arg: number);
    /**
     *
     * @returns {number}
     */
    get 1(): number;
    /**
     *
     * @param {number} v
     */
    set 2(arg: number);
    /**
     *
     * @returns {number}
     */
    get 2(): number;
    /**
     *
     * @param {number} v
     */
    set 3(arg: number);
    /**
     *
     * @returns {number}
     */
    get 3(): number;
    /**
     *
     * @param {number} v
     */
    set 4(arg: number);
    /**
     *
     * @returns {number}
     */
    get 4(): number;
    /**
     *
     * @param {number} v
     */
    set 5(arg: number);
    /**
     *
     * @returns {number}
     */
    get 5(): number;
    x0: number;
    y0: number;
    z0: number;
    x1: number;
    y1: number;
    z1: number;
    /**
     *
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @param {number} tolerance
     * @returns {boolean}
     */
    containsPointWithTolerance(x: number, y: number, z: number, tolerance: number): boolean;
    /**
     *
     * @returns {number}
     */
    computeSurfaceArea(): number;
    /**
     *
     * @returns {number}
     */
    getSurfaceArea(): number;
    /**
     *
     * @returns {number}
     */
    computeVolume(): number;
    /**
     *
     * @param {AABB3} other
     */
    copy(other: AABB3): void;
    /**
     *
     * @param {Number} x0
     * @param {Number} y0
     * @param {Number} z0
     * @param {Number} x1
     * @param {Number} y1
     * @param {Number} z1
     */
    setBounds(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
    /**
     *
     * @param {AABB3} other
     * @returns {boolean}
     */
    equals(other: AABB3): boolean;
    /**
     *
     * @param {Number} x0
     * @param {Number} y0
     * @param {Number} z0
     * @param {Number} x1
     * @param {Number} y1
     * @param {Number} z1
     * @returns {boolean}
     */
    _equals(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): boolean;
    /**
     * @returns {number}
     */
    hash(): number;
    /**
     * Same as setBounds, but does not require component pairs to be ordered (e.g. x0 <= x1). Method will enforce the correct order and invoke setBounds internally
     * @param {Number} x0
     * @param {Number} y0
     * @param {Number} z0
     * @param {Number} x1
     * @param {Number} y1
     * @param {Number} z1
     */
    setBoundsUnordered(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
    setNegativelyInfiniteBounds(): void;
    setInfiniteBounds(): void;
    /**
     *
     * @param {number} x
     * @param {number} y
     * @param {number} z
     */
    _translate(x: number, y: number, z: number): void;
    /**
     *
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {number} Squared distance to point, value is negative if the point is inside the box
     * @deprecated use {@link aabb3_signed_distance_sqr_to_point} directly
     */
    distanceToPoint2(x: number, y: number, z: number): number;
    /**
     *
     * @param {AABB3} box
     * @returns {number}
     */
    distanceToBox(box: AABB3): number;
    /**
     * Computes separation distance between two boxes.
     * If poxes penetrate or one is inside another - the result will be negative.
     * @param {number} x0
     * @param {number} y0
     * @param {number} z0
     * @param {number} x1
     * @param {number} y1
     * @param {number} z1
     * @returns {number}
     */
    _distanceToBox(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): number;
    /**
     *
     * @param {AABB3} other
     * @returns {number}
     * @deprecated
     */
    costForInclusion(other: AABB3): number;
    /**
     * Surface area delta when including a given AABB
     * 0 means that including a given AABB would not cause any change to total surface area
     * @param {number} x0
     * @param {number} y0
     * @param {number} z0
     * @param {number} x1
     * @param {number} y1
     * @param {number} z1
     * @returns {number}
     * @deprecated
     */
    _costForInclusion(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): number;
    /**
     *
     * @param {number} x
     * @param {number} y
     * @param {number} z
     * @returns {boolean}
     */
    _expandToFitPoint(x: number, y: number, z: number): boolean;
    /**
     *
     * @param {AABB3} other
     */
    union(other: AABB3): void;
    /**
     *
     * @param {AABB3} box
     * @returns {boolean}
     * @deprecated use {@link AABB3#union} instead
     */
    expandToFit(box: AABB3): boolean;
    /**
     *
     * @param {number} x0
     * @param {number} y0
     * @param {number} z0
     * @param {number} x1
     * @param {number} y1
     * @param {number} z1
     * @returns {boolean}
     */
    _expandToFit(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): boolean;
    /**
     *
     * @param {number} x0
     * @param {number} y0
     * @param {number} z0
     * @param {number} x1
     * @param {number} y1
     * @param {number} z1
     * @returns {boolean}
     */
    _containsBox(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): boolean;
    /**
     *
     * @param {AABB3} box
     * @returns {boolean}
     */
    containsBox(box: AABB3): boolean;
    /**
     *
     * @returns {number}
     */
    getExtentsX(): number;
    get width(): number;
    /**
     *
     * @returns {number}
     */
    getExtentsY(): number;
    get height(): number;
    /**
     *
     * @returns {number}
     */
    getExtentsZ(): number;
    get depth(): number;
    /**
     * half-width in X axis
     * @returns {number}
     */
    getHalfExtentsX(): number;
    /**
     * half-width in Y axis
     * @returns {number}
     */
    getHalfExtentsY(): number;
    /**
     * half-width in Z axis
     * @returns {number}
     */
    getHalfExtentsZ(): number;
    /**
     *
     * @param {Vector3} [target]
     * @returns {Vector3}
     */
    getExtents(target?: Vector3): Vector3;
    /**
     *
     * @returns {number}
     */
    getCenterX(): number;
    get centerX(): number;
    /**
     *
     * @returns {number}
     */
    getCenterY(): number;
    get centerY(): number;
    /**
     *
     * @returns {number}
     */
    getCenterZ(): number;
    get centerZ(): number;
    /**
     * Get center position of the box
     * @param {Vector3} [target] where to write result
     */
    getCenter(target?: Vector3): Vector3;
    /**
     * Accepts ray description, first set of coordinates is origin (oX,oY,oZ) and second is direction (dX,dY,dZ). Algorithm from GraphicsGems by Andrew Woo
     * @param oX
     * @param oY
     * @param oZ
     * @param dX
     * @param dY
     * @param dZ
     */
    intersectRay(oX: any, oY: any, oZ: any, dX: any, dY: any, dZ: any): boolean;
    intersectSegment(startX: any, startY: any, startZ: any, endX: any, endY: any, endZ: any): boolean;
    /**
     * @deprecated use {@link AABB3#_containsBox} instead
     * @param {THREE.Box} box
     * @returns {boolean}
     */
    threeContainsBox(box: THREE.Box): boolean;
    /**
     *
     * @param {function(x:number, y:number, z:number)} callback
     * @param {*} [thisArg]
     */
    traverseCorners(callback: any, thisArg?: any): void;
    /**
     *
     * @param {number[]|Float64Array|Float32Array} result
     */
    getCorners(result: number[] | Float64Array | Float32Array): void;
    /**
     *
     * @param {number[]|Float32Array|Float64Array} result
     * @param {number} offset
     */
    writeToArray(result?: number[] | Float32Array | Float64Array, offset?: number): number[] | Float32Array | Float64Array;
    /**
     *
     * @param {number[]|Float32Array|Float64Array} source
     * @param {number} offset
     */
    readFromArray(source: number[] | Float32Array | Float64Array, offset?: number): void;
    /**
     * @param {THREE.Plane} plane
     * @returns {int} 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
     */
    computePlaneSide(plane: THREE.Plane): int;
    /**
     *
     * @param {number} normal_x
     * @param {number} normal_y
     * @param {number} normal_z
     * @param {number} offset
     * @returns {number}
     */
    computeDistanceAbovePlane(normal_x: number, normal_y: number, normal_z: number, offset: number): number;
    /**
     *
     * @param {number} normal_x
     * @param {number} normal_y
     * @param {number} normal_z
     * @param {number} offset
     * @returns {boolean}
     */
    _isBelowPlane(normal_x: number, normal_y: number, normal_z: number, offset: number): boolean;
    /**
     *
     * @param {Plane} plane
     * @return {boolean}
     */
    isBelowPlane(plane: Plane): boolean;
    /**
     * @param {Plane[]} clippingPlanes
     * @returns {boolean}
     */
    intersectSpace(clippingPlanes: Plane[]): boolean;
    /**
     *
     * @param {Frustum} frustum
     * @returns {number}
     */
    intersectFrustumDegree(frustum: Frustum): number;
    /**
     *
     * @param {number[]} frustum
     * @returns {number}
     */
    intersectFrustumDegree_array(frustum: number[]): number;
    /**
     *
     * @param {{planes:Array}}frustum
     * @returns {boolean}
     */
    intersectFrustum(frustum: {
        planes: any[];
    }): boolean;
    /**
     *
     * @param {ArrayLike<number>|number[]|Float32Array}frustum
     * @returns {boolean}
     */
    intersectFrustum_array(frustum: ArrayLike<number> | number[] | Float32Array): boolean;
    /**
     *
     * @param {number[]|ArrayLike<number>|Float32Array} matrix
     */
    applyMatrix4(matrix: number[] | ArrayLike<number> | Float32Array): void;
    /**
     * Expands the box in all directions by the given amount
     * @param {number} extra
     */
    grow(extra: number): void;
    /**
     *
     * @returns {AABB3}
     */
    clone(): AABB3;
    fromJSON({ x0, y0, z0, x1, y1, z1 }: {
        x0: any;
        y0: any;
        z0: any;
        x1: any;
        y1: any;
        z1: any;
    }): void;
    toJSON(): {
        x0: number;
        y0: number;
        z0: number;
        x1: number;
        y1: number;
        z1: number;
    };
    toString(): string;
    /**
     * @readonly
     * @type {boolean}
     */
    readonly isAABB3: boolean;
    toArray: (result?: number[] | Float32Array | Float64Array, offset?: number) => number[] | Float32Array | Float64Array;
    fromArray: (source: number[] | Float32Array | Float64Array, offset?: number) => void;
    /**
     * Pretending to be an array
     * @readonly
     * @type {number}
     */
    readonly length: number;
    [Symbol.iterator](): Generator<number, void, unknown>;
}
import Vector3 from "../../Vector3.js";
//# sourceMappingURL=AABB3.d.ts.map