import { List } from "./gs.collections";
/**
 * 表示三维空间中的单精度点（Float32Array，长度为3）的工具类
 *
 * 提供点的加、减、克隆等常用操作，所有方法均为静态方法并返回或操作 Float32Array。
 */
export declare class Point {
    /**
     * 将两个点按分量相加，返回新的点
     * @param p1 第一个点（Float32Array，长度为3）
     * @param p2 第二个点（Float32Array，长度为3）
     * @returns 新的点（Float32Array，长度为3）
     */
    static add(p1: Float32Array, p2: Float32Array): Float32Array;
    /**
     * 将第一个点减去第二个点，按分量返回新的点
     * @param p1 被减的点（Float32Array，长度为3）
     * @param p2 减数点（Float32Array，长度为3）
     * @returns 新的点（Float32Array，长度为3）
     */
    static subtract(p1: Float32Array, p2: Float32Array): Float32Array;
    /**
     * 克隆一个点，返回新的 Float32Array 实例
     * @param p 要克隆的点（Float32Array，长度为3）
     * @returns 克隆后的点（Float32Array，长度为3）
     */
    static clone(p: Float32Array): Float32Array;
}
/**
 * 表示三维空间中的双精度点（Float64Array，长度为3）的工具类
 *
 * 与 `Point` 类似，但使用双精度浮点数组以提高数值精度。
 */
export declare class DPoint {
    /**
     * 将两个双精度点按分量相加，返回新的点
     * @param p1 第一个点（Float64Array，长度为3）
     * @param p2 第二个点（Float64Array，长度为3）
     * @returns 新的点（Float64Array，长度为3）
     */
    static add(p1: Float64Array, p2: Float64Array): Float64Array;
    /**
     * 将第一个双精度点减去第二个点，按分量返回新的点
     * @param p1 被减的点（Float64Array，长度为3）
     * @param p2 减数点（Float64Array，长度为3）
     * @returns 新的点（Float64Array，长度为3）
     */
    static subtract(p1: Float64Array, p2: Float64Array): Float64Array;
    /**
     * 克隆一个双精度点，返回新的 Float64Array 实例
     * @param p 要克隆的点（Float64Array，长度为3）
     * @returns 克隆后的点（Float64Array，长度为3）
     */
    static clone(p: Float64Array): Float64Array;
}
/**
 * 单精度向量（Float32Array，长度为3）工具类
 *
 * 包含向量检测、归一化、点乘、叉乘、角度计算等常用操作。
 */
export declare class Vector {
    /**
     * 判断向量是否为零向量（按分量与容差比较）
     * @param v 待检测的向量（Float32Array，长度为3）
     * @returns 若三个分量的绝对值均小于容差则返回 true，否则返回 false
     */
    static isZero(v: Float32Array): boolean;
    /**
     * 将向量按标量相乘并返回新的向量
     * @param v 源向量（Float32Array，长度为3）
     * @param num 标量
     * @returns 新的向量（Float32Array，长度为3）
     */
    static multiply(v: Float32Array, num: number): Float32Array;
    /**
     * 将向量按标量除并返回新的向量
     * @param v 源向量（Float32Array，长度为3）
     * @param num 标量
     * @returns 新的向量（Float32Array，长度为3）
     */
    static divide(v: Float32Array, num: number): Float32Array;
    /**
     * 就地归一化向量（修改传入数组）
     * @param v 将被归一化的向量（Float32Array，长度为3）
     */
    static normalize(v: Float32Array): void;
    /**
     * 返回归一化后的新向量，不修改输入
     * @param v 源向量（Float32Array，长度为3）
     * @returns 新的单位向量（Float32Array，长度为3），若长度接近 0 则返回全 0 向量
     */
    static normalizeVector(v: Float32Array): Float32Array;
    /**
     * 向量点乘（标量积）
     * @param v1 向量1（Float32Array，长度为3）
     * @param v2 向量2（Float32Array，长度为3）
     * @returns 标量点积
     */
    static multi(v1: Float32Array, v2: Float32Array): number;
    /**
     * 向量叉乘（返回新向量）
     * @param v1 向量1（Float32Array，长度为3）
     * @param v2 向量2（Float32Array，长度为3）
     * @returns 叉乘结果向量（Float32Array，长度为3）
     */
    static cross(v1: Float32Array, v2: Float32Array): Float32Array;
    /**
     * 计算向量长度（模）
     * @param v 向量（Float32Array，长度为3）
     * @returns 向量的模长
     */
    static module(v: Float32Array): number;
    /**
     * 就地取反向量（每个分量取负）
     * @param v 将被取反的向量（Float32Array，长度为3）
     */
    static reverse(v: Float32Array): void;
    /**
     * 克隆向量并返回新实例
     * @param v 待克隆向量（Float32Array，长度为3）
     * @returns 克隆后的向量（Float32Array，长度为3）
     */
    static clone(v: Float32Array): Float32Array;
    /**
     * 计算两个向量的包含角（使用叉乘求 sin）
     * @param v0 向量0（Float32Array，长度为3）
     * @param v1 向量1（Float32Array，长度为3）
     * @returns 两向量之间的夹角（弧度）
     */
    static includeAngle(v0: Float32Array, v1: Float32Array): number;
    /**
     * 计算向量 v0 与 v1 之间的夹角（以弧度表示），并可根据给定的法向量确定方向（顺时针或逆时针）。
     * @param v0 - 第一个向量（Float32Array）
     * @param v1 - 第二个向量（Float32Array）
     * @param normal - 可选的法向量（Float32Array）。用于根据法向量判断方向性，从而决定是否将结果修正为 2π - alpha。
     * @returns 两向量之间的角度（以弧度为单位）。在向量为零时返回 0.0；在提供 normal 并且方向需被反转时可能返回接近 2π 的值。
     */
    static angle(v0: Float32Array, v1: Float32Array, normal?: Float32Array): number;
}
/**
 * 双精度向量（Float64Array，长度为3）工具类
 *
 * 提供与 `Vector` 类似的功能，但使用双精度浮点数以提高数值稳定性。
 */
export declare class DVector {
    /**
     * 判断双精度向量是否为零向量（按分量与容差比较）
     * @param v 待检测的向量（Float64Array，长度为3）
     * @returns 若三个分量的绝对值均小于容差则返回 true，否则返回 false
     */
    static isZero(v: Float64Array): boolean;
    /**
     * 将双精度向量按标量相乘并返回新的向量
     * @param v 源向量（Float64Array，长度为3）
     * @param num 标量
     * @returns 新的向量（Float64Array，长度为3）
     */
    static multiply(v: Float64Array, num: number): Float64Array;
    /**
     * 将双精度向量按标量除并返回新的向量
     * @param v 源向量（Float64Array，长度为3）
     * @param num 标量
     * @returns 新的向量（Float64Array，长度为3）
     */
    static divide(v: Float64Array, num: number): Float64Array;
    /**
     * 就地归一化双精度向量（修改传入数组）
     * @param v 将被归一化的向量（Float64Array，长度为3）
     */
    static normalize(v: Float64Array): void;
    /**
     * 返回归一化后的新双精度向量，不修改输入
     * @param v 源向量（Float64Array，长度为3）
     * @returns 新的单位向量（Float64Array，长度为3），若长度接近 0 则返回全 0 向量
     */
    static normalizeVector(v: Float64Array): Float64Array;
    /**
     * 双精度向量点乘（标量积）
     * @param v1 向量1（Float64Array，长度为3）
     * @param v2 向量2（Float64Array，长度为3）
     * @returns 标量点积
     */
    static multi(v1: Float64Array, v2: Float64Array): number;
    /**
     * 双精度向量叉乘（返回新向量）
     * @param v1 向量1（Float64Array，长度为3）
     * @param v2 向量2（Float64Array，长度为3）
     * @returns 叉乘结果向量（Float64Array，长度为3）
     */
    static cross(v1: Float64Array, v2: Float64Array): Float64Array;
    /**
     * 计算双精度向量长度（模）
     * @param v 向量（Float64Array，长度为3）
     * @returns 向量的模长
     */
    static module(v: Float64Array): number;
    /**
     * 就地取反双精度向量（每个分量取负）
     * @param v 将被取反的向量（Float64Array，长度为3）
     */
    static reverse(v: Float64Array): void;
    /**
     * 克隆双精度向量并返回新实例
     * @param v 待克隆向量（Float64Array，长度为3）
     * @returns 克隆后的向量（Float64Array，长度为3）
     */
    static clone(v: Float64Array): Float64Array;
    /**
     * 计算两个双精度向量的包含角（使用叉乘求 sin）
     * @param v0 向量0（Float64Array，长度为3）
     * @param v1 向量1（Float64Array，长度为3）
     * @returns 两向量之间的夹角（弧度）
     */
    static includeAngle(v0: Float64Array, v1: Float64Array): number;
    /**
      * 计算向量 v0 与 v1 之间的夹角（以弧度表示），并可根据给定的法向量确定方向（顺时针或逆时针）。
      * @param v0 - 第一个向量（Float32Array）
      * @param v1 - 第二个向量（Float32Array）
      * @param normal - 可选的法向量（Float32Array）。用于根据法向量判断方向性，从而决定是否将结果修正为 2π - alpha。
      * @returns 两向量之间的角度（以弧度为单位）。在向量为零时返回 0.0；在提供 normal 并且方向需被反转时可能返回接近 2π 的值。
      */
    static angle(v0: Float64Array, v1: Float64Array, normal?: Float64Array): number;
}
/**
 * 4x4 单精度矩阵工具类
 *
 * 提供矩阵克隆、单位矩阵、相乘、逆、转置、投影、分解等常用操作。
 */
export declare class Matrix4 {
    /**
     * 内部矩阵数据（长度为16 的 Float32Array）
     */
    _data: Float32Array;
    /**
     * 克隆矩阵数据到指定目标或返回新的矩阵副本
     * @param m 源矩阵（Float32Array，长度为16）
     * @param mat 可选的目标矩阵（Float32Array），若提供则写入并返回 void，否则返回新的副本
     */
    static clone(m: Float32Array, mat?: Float32Array): Float32Array;
    /**
     * 返回 4x4 单位矩阵
     * @returns 单位矩阵（Float32Array，长度为16）
     */
    static identity(): Float32Array;
    /**
     * 判断矩阵是否为近似单位矩阵（使用容差比较）
     * @param m 矩阵（Float32Array，长度为16）
     * @returns 若每个分量与单位矩阵相应分量在容差内，则返回 true
     */
    static isIdentity(m: Float32Array): boolean;
    /**
     * 矩阵相乘
     * @param m1
     * @param m2
     * @returns
     */
    static multiply(m1: Float32Array, m2: Float32Array, mat?: Float32Array): Float32Array;
    /**
   * 按列主序矩阵乘法（与 multiply 不同的索引顺序），支持写入目标矩阵
   * @param m1 左矩阵（Float32Array，长度为16）
   * @param m2 右矩阵（Float32Array，长度为16）
   * @param mat 可选的目标矩阵（Float32Array），若提供则填充并返回该矩阵
   */
    static multiplyReverse(m1: Float32Array, m2: Float32Array, mat?: Float32Array): Float32Array;
    /**
     * 点矩阵变换
     * @param m 矩阵
     * @param p 点
     * @returns 变换后的点
     */
    static multiplyPoint(m: Float32Array, p: Float32Array): Float32Array;
    /**
     * 点矩阵变换, 包含w维
     * @param m 矩阵
     * @param p 点
     * @returns 变换后的点
     */
    static multiplyWPoint(m: Float32Array, p: Float32Array): Float32Array;
    /**
     * 点数组矩阵变换
     * @param m 矩阵
     * @param p 点数组
     * @returns 变换后的点数组
     */
    static multiplyPoints(m: Float32Array, ps: Float32Array): Float32Array;
    /**
     * 矩阵乘向量（用于变换方向向量，不包含平移分量）
     * @param m 矩阵（Float32Array，长度为16）
     * @param v 向量（Float32Array，长度为3）
     * @returns 变换后的向量（Float32Array，长度为3）
     */
    static multiplyVector(m: Float32Array, v: Float32Array): Float32Array;
    /**
     * 使用矩阵变换轴对齐包围盒（通过计算 8 个顶点并求 min/max）
     * @param m 变换矩阵（Float32Array，长度为16）
     * @param bb 包围盒 [minX,minY,minZ,maxX,maxY,maxZ]（Float32Array，长度为6）
     * @returns 变换后的包围盒（Float32Array，长度为6）
     */
    static multiplyBoundingBox(m: Float32Array, bb: Float32Array): Float32Array;
    /**
     * 就地计算矩阵的逆，结果写回参数矩阵（若不可逆则返回 undefined）
     * @param m 要求逆的矩阵（Float32Array，长度为16），函数会修改该矩阵以保存逆矩阵
     */
    static Inverse(m: Float32Array): void;
    /**
      * 返回矩阵的逆的副本（不修改原始矩阵）
      * @param m 源矩阵（Float32Array，长度为16）
      * @returns 逆矩阵的副本（Float32Array，长度为16）
      */
    static InverseMatrix(m: Float32Array): Float32Array;
    /**
     * 就地转置矩阵（修改参数矩阵）
     * @param m 待转置的矩阵（Float32Array，长度为16）
     */
    static Transpose(m: Float32Array): void;
    /**
     * 返回转置矩阵的副本（不修改原始矩阵）
     * @param m 源矩阵（Float32Array，长度为16）
     * @returns 转置后的新矩阵（Float32Array，长度为16）
     */
    static TransposeMatrix(m: Float32Array): Float32Array;
    /**
     * 创建一个平移矩阵（基于给定的 x,y,z 偏移）
     * @param x X 方向平移量
     * @param y Y 方向平移量
     * @param z Z 方向平移量
     * @returns 平移矩阵（Float32Array，长度为16）
     */
    static translateMatrix(x: number, y: number, z: number): Float32Array;
    /**
     * 将给定矩阵按指定平移量进行就地平移（修改矩阵）
     * @param m 要应用平移的矩阵（Float32Array，长度为16）
     * @param x X 方向平移量
     * @param y Y 方向平移量
     * @param z Z 方向平移量
     */
    static translate(m: Float32Array, x: number, y: number, z: number): void;
    /**
      * 创建缩放矩阵
      * @param x X 方向缩放因子
      * @param y Y 方向缩放因子
      * @param z Z 方向缩放因子
      * @returns 缩放矩阵（Float32Array，长度为16）
      */
    static scaleMatrix(x: number, y: number, z: number): Float32Array;
    /**
     * 就地缩放矩阵（修改矩阵的缩放部分）
     * @param m 要修改的矩阵（Float32Array，长度为16）
     * @param x X 方向缩放因子
     * @param y Y 方向缩放因子
     * @param z Z 方向缩放因子
     */
    static scale(m: Float32Array, x: number, y: number, z: number): void;
    /**
     * 绕任意轴旋转，返回 4x4 旋转矩阵
     * @param axis 旋转轴向量（Float32Array，长度为3，应为单位向量）
     * @param alpha 旋转角度（弧度）
     * @returns 旋转矩阵（Float32Array，长度为16）
     */
    static rotate(axis: Float32Array, alpha: number): Float32Array;
    /**
     * 绕 X 轴旋转并返回旋转矩阵
     * @param alpha 旋转角度（弧度）
     */
    static rotationX(alpha: number): Float32Array;
    /**
     * 绕 Y 轴旋转并返回旋转矩阵
     * @param alpha 旋转角度（弧度）
     */
    static rotationY(alpha: number): Float32Array;
    /**
     * 绕 Z 轴旋转并返回旋转矩阵
     * @param alpha 旋转角度（弧度）
     */
    static rotationZ(alpha: number): Float32Array;
    /**
     * 指定点轴旋转
     * @param origin 点
     * @param axis 旋转轴
     * @param alpha 弧度
     * @returns 变换矩阵
     */
    static rotateByAxis(origin: Float32Array, axis: Float32Array, alpha: number): Float32Array;
    /**
     * 创建或写入正交投影矩阵
     * @param left 视体左边界
     * @param right 视体右边界
     * @param bottom 视体下边界
     * @param top 视体上边界
     * @param near 近裁剪面
     * @param far 远裁剪面
     * @param mat 可选目标矩阵
     * @returns 正交投影矩阵（Float32Array，长度为16）
     */
    static ortho(left: number, right: number, bottom: number, top: number, near: number, far: number, mat?: Float32Array): Float32Array;
    /**
     * 创建透视投影矩阵
     * @param fov 垂直视野（弧度）
     * @param aspect 纵横比（width/height）
     * @param near 近裁剪面
     * @param far 远裁剪面
     * @param mat 可选目标矩阵
     * @returns 透视投影矩阵（Float32Array，长度为16）
     */
    static perspective(fov: number, aspect: number, near: number, far: number, mat?: Float32Array): any;
    /**
     * 根据视锥体参数创建透视投影矩阵
     * @param left 左边界
     * @param right 右边界
     * @param bottom 底部
     * @param top 顶部
     * @param fnear 近裁剪面
     * @param ffar 远裁剪面
     * @returns 透视投影矩阵（Float32Array，长度为16）
     */
    static frustum(left: number, right: number, bottom: number, top: number, fnear: number, ffar: number): Float32Array;
    /**
     * 创建观察矩阵（LookAt），将相机从 eye 看向 center，使用 up 指定上方向
     * @param eyeX 相机位置 X
     * @param eyeY 相机位置 Y
     * @param eyeZ 相机位置 Z
     * @param centerX 目标点 X
     * @param centerY 目标点 Y
     * @param centerZ 目标点 Z
     * @param upX up 向量 X 分量
     * @param upY up 向量 Y 分量
     * @param upZ up 向量 Z 分量
     * @param mat 可选目标矩阵
     * @returns 观察矩阵（Float32Array，长度为16）
     */
    static lookat(eyeX: number, eyeY: number, eyeZ: number, centerX: number, centerY: number, centerZ: number, upX: number, upY: number, upZ: number, mat?: Float32Array): Float32Array;
    /**
     * 提取矩阵中的平移部分并返回平移矩阵
     * @param m 源矩阵（Float32Array，长度为16）
     * @returns 只包含平移分量的矩阵（Float32Array，长度为16）
     */
    static getTranslate(m: Float32Array): Float32Array;
    /**
     * 从矩阵中提取缩放分量并返回对应的缩放矩阵
     * @param m 源矩阵（Float32Array，长度为16）
     * @returns 包含缩放分量的矩阵（Float32Array，长度为16）
     */
    static getScale(m: Float32Array): Float32Array;
    /**
     * 从矩阵中提取旋转部分（移除平移与缩放），返回只包含旋转的矩阵
     * @param m 源矩阵（Float32Array，长度为16）
     * @returns 只包含旋转分量的矩阵（Float32Array，长度为16）
     */
    static getRotate(m: Float32Array): Float32Array;
    /**
     * 将点应用于投影矩阵并进行齐次除法，返回投影后的点（包含归一化）
     * @param m 投影矩阵（Float32Array，长度为16）
     * @param point 三维点（Float32Array，长度为3）
     * @returns 投影并归一化后的四维点（Float32Array，长度为4）
     */
    static multiplyPointProjection(m: Float32Array, point: Float32Array): Float32Array;
    /**
     * 对包围盒进行投影变换并返回在投影空间中的包围盒
     * @param m 投影矩阵（Float32Array，长度为16）
     * @param bb 包围盒 [minX,minY,minZ,maxX,maxY,maxZ]（Float32Array，长度为6）
     * @returns 投影后的包围盒（Float32Array，长度为6）
     */
    static multiplyBBProjection(m: Float32Array, bb: Float32Array): Float32Array;
    /**
     * 将当前矩阵分解为平移、旋转和缩放分量
     * @param scale 作为引用传入并更新的缩放向量（Vector3）
     * @param quaternion 作为引用传入并更新的旋转四元数（Quaternion）
     * @param translation 作为引用传入并更新的平移向量（Vector3）
     * @param preserveScalingNode 可选。从该节点获取缩放符号以保留缩放方向，否则缩放符号可能会改变
     * @param useAbsoluteScaling 当为 true 时从 preserveScalingNode.absoluteScaling 获取符号，否则从 preserveScalingNode.scaling 获取
     * @returns 若分解成功则返回 true
     */
    static decompose(matrix: Float32Array, scale: Float32Array, quaternion: Float32Array, translation: Float32Array, preserveScalingNode?: any, useAbsoluteScaling?: boolean): boolean;
    /**
     * 使用给定的旋转矩阵数值更新目标四元数
     * @param matrix 定义来源矩阵
     * @param result 定义目标四元数（将被更新）
     * @returns 返回传入的 result
     */
    private static FromRotationMatrixToRef;
    private static fromValuesToRef;
    /**
     * 获取矩阵的行列式
     * 示例（Playground）
     * 计算 4x4 矩阵的行列式使用拉普拉斯展开（Laplace expansion）：对某一行或列计算余子式并加权求和得到行列式。
     * @returns 矩阵的行列式
     */
    static determinant(matrix: Float32Array): number;
    /**
     * 将四元数转换为欧拉角（以弧度表示）
     * @param quaternion 要转换的四元数（Float32Array，长度为4）
     * @returns 以弧度表示的欧拉角（Float32Array，长度为3）
     */
    static toEulerAngles(quaternion: Float32Array): Float32Array;
    /**
     * 使用当前四元数设置传入的三维向量 result 为对应的欧拉角（以弧度为单位）
     * @param result 将被填充为欧拉角的目标向量（会被修改）
     * @returns 返回传入的 result
     */
    private static toEulerAnglesToRef;
    /**
     * 从欧拉角向量创建四元数
     * @param vec 欧拉旋转向量，格式为 [x, y, z]，其中 x 表示俯仰（Pitch），y 表示偏航（Yaw），z 表示横滚（Roll）
     * @returns 新的四元数（Float32Array，长度为4）
     */
    static fromEulerVector(rotation: Float32Array): Float32Array;
    /**
     * 从给定的欧拉角（顺序为 yaw, pitch, roll，即绕 Y、X、Z 轴）创建一个新的旋转并存入目标四元数
     * @param yaw 表示绕 Y 轴的旋转（弧度）
     * @param pitch 表示绕 X 轴的旋转（弧度）
     * @param roll 表示绕 Z 轴的旋转（弧度）
     * @param result 目标四元数（将被写入）
     * @returns 返回传入的 result
     */
    private static rotationYawPitchRollToRef;
    /**
     * 根据缩放（Vector3）、旋转（四元数）和平移（Vector3）合成新的矩阵
     * @param scale 定义缩放向量（Float32Array，长度为3）
     * @param quaternion 定义旋转四元数（Float32Array，长度为4）
     * @param translation 定义平移向量（Float32Array，长度为3）
     * @returns 新的 4x4 变换矩阵（Float32Array，长度为16）
     */
    static compose(scale: Float32Array, quaternion: Float32Array, translation: Float32Array): Float32Array;
    /**
     * 将由缩放、旋转（四元数）和平移合成的矩阵创建并返回
     * @param scale 定义缩放向量（Float32Array，长度为3）
     * @param quaternion 定义旋转四元数（Float32Array，长度为4）
     * @param translation 定义平移向量（Float32Array，长度为3）
     * @returns 合成后的 4x4 矩阵（Float32Array，长度为16）
     */
    private static composeToRef;
}
export declare class DMatrix4 {
    /**
     * 克隆双精度矩阵到新实例
     * @param m 源矩阵（Float64Array，长度为16）
     * @returns 克隆后的矩阵（Float64Array，长度为16）
     */
    static clone(m: Float64Array): Float64Array;
    /**
     * 返回 4x4 单位矩阵（双精度）
     * @returns 单位矩阵（Float64Array，长度为16）
     */
    static identity(): Float64Array;
    /**
     * 矩阵相乘（双精度）
     * @param m1 左矩阵（Float64Array，长度为16）
     * @param m2 右矩阵（Float64Array，长度为16）
     * @returns 相乘结果矩阵（Float64Array，长度为16）
     */
    static multiply(m1: Float64Array, m2: Float64Array): Float64Array;
    /**
   * 点矩阵变换（双精度）
   * @param m 矩阵（Float64Array，长度为16）
   * @param p 点（Float64Array，长度为3）
   * @returns 变换后的点（Float64Array，长度为3）
   */
    static multiplyPoint(m: Float64Array, p: Float64Array): Float64Array;
    /**
   * 矩阵乘向量（双精度），不包含平移分量
   * @param m 矩阵（Float64Array，长度为16）
   * @param v 向量（Float64Array，长度为3）
   * @returns 变换后的向量（Float64Array，长度为3）
   */
    static multiplyVector(m: Float64Array, v: Float64Array): Float64Array;
    /**
   * 变换包围盒（双精度），返回变换后的包围盒
   * @param m 变换矩阵（Float64Array，长度为16）
   * @param bb 包围盒 [minX,minY,minZ,maxX,maxY,maxZ]（Float64Array，长度为6）
   * @returns 变换后的包围盒（Float64Array，长度为6）
   */
    static multiplyBoundingBox(m: Float64Array, bb: Float64Array): Float64Array;
    /**
   * 就地计算双精度矩阵的逆，结果写回参数矩阵（若不可逆则返回 undefined）
   * @param m 要求逆的矩阵（Float64Array，长度为16），函数会修改该矩阵以保存逆矩阵
   */
    static Inverse(m: Float64Array): void;
    /**
     * 计算并返回给定 4x4 矩阵的逆矩阵（不修改原始输入）。
     * @param m - 要求逆的 4x4 矩阵，类型为 Float64Array，长度应为 16。
     * @returns 返回一个新的 Float64Array，表示输入矩阵的逆矩阵。
     */
    static InverseMatrix(m: Float64Array): Float64Array;
    /**
     * 将 4x4 矩阵原地转置。
     * @param m - 长度至少为 16 的 Float64Array，表示列主序的 4x4 矩阵。该数组会被原地修改。
     * @returns void
     */
    static Transpose(m: Float64Array): void;
    /**
     * 将给定的 4x4 矩阵转置并返回新的矩阵副本。
     * 不会修改传入的 m，而是先克隆后对克隆结果进行转置并返回。
     * @param m - 要转置的矩阵，使用 Float64Array 表示，预期长度为 16（4x4）。
     * @returns 返回转置后的 Float64Array（新的数组实例）。
     */
    static TransposeMatrix(m: Float64Array): Float64Array;
    /**
     * 生成一个 4x4 的平移矩阵（列主序）。
     *
     * @param x - 沿 X 轴的平移距离
     * @param y - 沿 Y 轴的平移距离
     * @param z - 沿 Z 轴的平移距离
     * @returns 返回表示 4x4 平移矩阵的 Float64Array
     */
    static translateMatrix(x: number, y: number, z: number): Float64Array;
    /**
     * 将平移应用到给定的 4x4 矩阵（原地修改）。
     *
     * @param m - 目标矩阵，长度为 16 的 Float64Array（按列主序排列）。
     * @param x - 在 X 方向上的平移量。
     * @param y - 在 Y 方向上的平移量。
     * @param z - 在 Z 方向上的平移量。
     * @returns void - 无返回值；函数会直接修改传入的矩阵 m 的平移分量。
     */
    static translate(m: Float64Array, x: number, y: number, z: number): void;
    /**
     * 创建一个 4x4 缩放矩阵。
     * @param x - (X 轴缩放因子)
     * @param y - (Y 轴缩放因子)
     * @param z - (Z 轴缩放因子)
     * @returns 返回长度为 16 的 Float64Array，表示对角线为 [x, y, z, 1] 的 4x4 缩放矩阵。
     */
    static scaleMatrix(x: number, y: number, z: number): Float64Array;
    /**
     * 将缩放因子应用于给定矩阵的缩放分量并直接修改该矩阵。
     * @param m - 要修改的矩阵数组
     * @param x - X 轴缩放因子
     * @param y - Y 轴缩放因子
     * @param z - Z 轴缩放因子
     * @returns 无返回值，直接在输入矩阵上生效
     */
    static scale(m: Float64Array, x: number, y: number, z: number): void;
    /**
      使用罗德里格斯（Rodrigues）旋转公式，根据给定轴和角度生成一个 4x4 旋转矩阵。
     * @param axis - 表示旋转轴的长度为 3 的 Float64Array，应为单位向量（若不是请先归一化）。
     * @param alpha - 旋转角度，单位为弧度。
     * @returns 返回值为长度为 16 的 Float64Array，按列优先（column-major）排列的 4x4 旋转矩阵，属于齐次变换（底行为 [0, 0, 0, 1]）。
     */
    static rotate(axis: Float64Array, alpha: number): Float64Array;
    /**
   * 指定点轴旋转
   * @param origin 点
   * @param axis 旋转轴
   * @param alpha 弧度
   * @returns 变换矩阵
   */
    static rotateByAxis(origin: Float64Array, axis: Float64Array, alpha: number): Float64Array;
    /**
   * 创建或写入正交投影矩阵
   * @param left 视体左边界
   * @param right 视体右边界
   * @param bottom 视体下边界
   * @param top 视体上边界
   * @param near 近裁剪面
   * @param far 远裁剪面
   * @param mat 可选目标矩阵
   * @returns 正交投影矩阵（Float32Array，长度为16）
   */
    static ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Float64Array;
    /**
   * 创建观察矩阵（LookAt），将相机从 eye 看向 center，使用 up 指定上方向
   * @param eyeX 相机位置 X
   * @param eyeY 相机位置 Y
   * @param eyeZ 相机位置 Z
   * @param centerX 目标点 X
   * @param centerY 目标点 Y
   * @param centerZ 目标点 Z
   * @param upX up 向量 X 分量
   * @param upY up 向量 Y 分量
   * @param upZ up 向量 Z 分量
   * @param mat 可选目标矩阵
   * @returns 观察矩阵（Float32Array，长度为16）
   */
    static lookat(eyeX: number, eyeY: number, eyeZ: number, centerX: number, centerY: number, centerZ: number, upX: number, upY: number, upZ: number): Float64Array;
    /**
   * 提取矩阵中的平移部分并返回平移矩阵
   * @param m 源矩阵（Float32Array，长度为16）
   * @returns 只包含平移分量的矩阵（Float32Array，长度为16）
   */
    static getTranslate(m: Float64Array): Float64Array;
    /**
   * 从矩阵中提取缩放分量并返回对应的缩放矩阵
   * @param m 源矩阵（Float32Array，长度为16）
   * @returns 包含缩放分量的矩阵（Float32Array，长度为16）
   */
    static getScale(m: Float64Array): Float64Array;
    /**
   * 从矩阵中提取旋转部分（移除平移与缩放），返回只包含旋转的矩阵
   * @param m 源矩阵（Float32Array，长度为16）
   * @returns 只包含旋转分量的矩阵（Float32Array，长度为16）
   */
    static getRotate(m: Float64Array): Float64Array;
    /**
   * 对包围盒进行投影变换并返回在投影空间中的包围盒
   * @param m 投影矩阵（Float32Array，长度为16）
   * @param bb 包围盒 [minX,minY,minZ,maxX,maxY,maxZ]（Float32Array，长度为6）
   * @returns 投影后的包围盒（Float32Array，长度为6）
   */
    static multiplyBBProjection(m: Float64Array, bb: Float64Array): Float64Array;
}
/**
 * 局部坐标系（单精度）
 *
 * 封装原点与三轴，并提供从模型坐标与局部坐标之间的变换方法。
 */
export declare class Wcs {
    /** 原点（Float32Array，长度为3） */
    origin: Float32Array;
    /** 局部 X 轴（单位向量，Float32Array，长度为3） */
    x_axis: Float32Array;
    /** 局部 Y 轴（单位向量，Float32Array，长度为3） */
    y_axis: Float32Array;
    /** 局部 Z 轴（单位向量，Float32Array，长度为3） */
    z_axis: Float32Array;
    /** 局部变换矩阵（从模型到局部） */
    local: Float32Array;
    /** 模型变换矩阵（从局部到模型） */
    model: Float32Array;
    constructor(origin: Float32Array, x_axis: Float32Array, y_axis: Float32Array);
    /** 将模型空间的点转换为局部坐标 */
    toLocalPoint(point: Float32Array): Float32Array;
    /** 将模型空间的向量转换为局部坐标（不包含平移） */
    toLocalVector(vector: Float32Array): Float32Array;
    /** 将局部坐标的点转换为模型（世界）坐标 */
    toModelPoint(point: Float32Array): Float32Array;
    /** 将局部坐标的向量转换为模型（世界）坐标（不包含平移） */
    toModelVector(vector: Float32Array): Float32Array;
}
/**
 * 局部坐标系（双精度）
 *
 * 与 `Wcs` 类似，但使用双精度数组以提高数值精度。
 */
export declare class DWcs {
    /** 原点（Float64Array，长度为3） */
    origin: Float64Array;
    /** 局部 X 轴（Float64Array，长度为3） */
    x_axis: Float64Array;
    /** 局部 Y 轴（Float64Array，长度为3） */
    y_axis: Float64Array;
    /** 局部 Z 轴（Float64Array，长度为3） */
    z_axis: Float64Array;
    /** 局部变换矩阵（Float64Array） */
    local: Float64Array;
    /** 模型变换矩阵（Float64Array） */
    model: Float64Array;
    constructor(origin: Float64Array, x_axis: Float64Array, y_axis: Float64Array);
    /**
     * 获取局部坐标位置
     * @param point
     * @returns
     */
    toLocalPoint(point: Float64Array): Float64Array;
    /**
     * 获取局部坐标位置列表
     * @param points
     * @returns
     */
    toLocalPoints(points: Float64Array): Float64Array;
    /**
     * 获取局部坐标法向
     * @param vector
     * @returns
     */
    toLocalVector(vector: Float64Array): Float64Array;
    /**
     * 获取世界坐标位置
     * @param point
     * @returns
     */
    toModelPoint(point: Float64Array): Float64Array;
    /**
     * 获取世界坐标位置列表
     * @param points
     * @returns
     */
    toModelPoints(points: Float64Array): Float64Array;
    /**
     * 获取世界坐标法向
     * @param vector
     * @returns
     */
    toModelVector(vector: Float64Array): Float64Array;
}
/**
 * 单精度容差工具类
 *
 * 提供全局容差数值以及用于比较数值/数组的辅助方法。
 */
export declare class Tolerance {
    /** 绝对容差 */
    static resabs: number;
    /** 法线相关容差 */
    static resnor: number;
    /**
     * 判断两个数是否在绝对容差范围内相等
     * @param a 数值 a
     * @param b 数值 b
     */
    static sameValue(a: number, b: number): boolean;
    /**
     * 比较两个 Float32Array 是否逐元素相等（基于绝对容差）
     * @param a 数组 a
     * @param b 数组 b
     */
    static sameValueFloatArray(a: Float32Array, b: Float32Array): boolean;
    /**
     * 判断值 v 是否在区间 [a,b]（含边界）内，考虑容差
     * @param v 待判断值
     * @param a 区间一端
     * @param b 区间另一端
     */
    static isValueInInterval(v: number, a: number, b: number): boolean;
}
/**
 * 双精度容差工具类
 */
export declare class DTolerance {
    /** 双精度绝对容差 */
    static resabs: number;
    /** 双精度法线容差 */
    static resnor: number;
    /**
     * 判断两个双精度数是否在容差内相等
     */
    static sameValue(a: number, b: number): boolean;
    /**
     * 使用指定容差判断两个数是否相等
     */
    static sameValueWithTolerance(a: number, b: number, tolerance: number): boolean;
    /**
     * 比较两个 Float64Array 是否逐元素相等（基于双精度绝对容差）
     */
    static sameValueFloatArray(a: Float64Array, b: Float64Array): boolean;
}
/**
 * 轴对齐包围盒工具（单精度）
 *
 * 包含包围盒的初始化、扩展、查询等常用操作，包围盒使用 [minX,minY,minZ,maxX,maxY,maxZ] 的表示。
 */
export declare class BoundingBox {
    /** 将包围盒设置为“空”状态（便于后续 extend 操作） */
    static setNull(bb: Float32Array): void;
    static isNull(bb: Float32Array): boolean;
    /**
     * 将包围盒 b 合并到 bb 中（就地修改 bb）
     */
    static extend(bb: Float32Array, b: Float32Array): void;
    /**
     * 将单点扩展到包围盒中（就地修改 bb）
     */
    static extendByPoint(bb: Float32Array, pt: Float32Array): void;
    /** 返回包围盒中心点 */
    static center(bb: Float32Array): Float32Array;
    /** 返回包围盒最小点 */
    static min(bb: Float32Array): Float32Array;
    /** 返回包围盒最大点 */
    static max(bb: Float32Array): Float32Array;
    /** 返回包围盒外接球的半径 */
    static radius(bb: Float32Array): number;
    /** 判断包围盒是否相交 */
    static isIntersecting(bb1: Float32Array, bb2: Float32Array): boolean;
    /** 判断点是否在包围盒内（考虑容差） */
    static isPointIn(p: Float32Array, bb: Float32Array): boolean;
    /** 根据点集合创建包围盒 */
    static from(points: Float32Array[]): Float32Array;
    /** 根据点集合创建包围盒 */
    static from1(points: Float32Array): Float32Array;
}
/**
 * 轴对齐包围盒工具（双精度）
 *
 * 与 `BoundingBox` 对应，但使用 `Float64Array` 存储值，适用于需要更高精度的场景。
 */
export declare class DBoundingBox {
    /** 将包围盒设置为“空”状态（便于后续 extend 操作） */
    static setNull(bb: Float64Array): void;
    /** 判断包围盒是否为空 */
    static isNull(bb: Float64Array): boolean;
    /** 将包围盒 b 合并到 bb 中（就地修改 bb） */
    static extend(bb: Float64Array, b: Float64Array): void;
    /** 将单点扩展到包围盒中（就地修改 bb） */
    static extendByPoint(bb: Float64Array, pt: Float64Array): void;
    /** 返回包围盒中心点 */
    static center(bb: Float64Array): Float64Array;
    /** 返回包围盒外接球的半径 */
    static radius(bb: Float64Array): number;
    /** 判断点是否在包围盒内（考虑容差） */
    static isPointIn(p: Float64Array, bb: Float64Array): boolean;
    /** 根据点集合创建包围盒 */
    static from(points: Float64Array[]): Float64Array;
    /** 根据平面点数组创建包围盒（数组按 xyz xyz ... 排列） */
    static from1(points: Float64Array): Float64Array;
}
/**
 * 常用几何运算函数集合（单精度）
 *
 * 提供线线求交、点到线/平面投影、多边形相关判断、距离与角度计算等工具函数。
 */
export declare class GeometryOperators {
    /** 将角度转换为弧度 */
    static angleToRadian(angle: number): number;
    /**
     * 计算两条无穷直线（由点 p0,p1 与方向 v0,v1 表示）之间最近点对及参数
     * @returns 若平行则返回 null，否则返回 { param0, param1, rp0, rp1 }
     */
    static closestPoint(p0: Float32Array, v0: Float32Array, p1: Float32Array, v1: Float32Array): any;
    /** 计算两条直线的交点（若存在唯一交点） */
    static intersectionLineLine(line0_p0: Float32Array, line0_p1: Float32Array, line1_p0: Float32Array, line1_p1: Float32Array): any;
    /** 与 intersectionLineLine 相似，但使用点+方向向量表示直线 */
    static intersectionLineLine1(line0_point: Float32Array, line0_direct: Float32Array, line1_point: Float32Array, line1_direct: Float32Array): any;
    /** 计算两条线段是否相交，若相交返回交点位置，否则返回 null */
    static intersectionLineSegmentLineSegment(line0_p0: Float32Array, line0_p1: Float32Array, line1_p0: Float32Array, line1_p1: Float32Array): any;
    /** 计算线段与平面的交点，返回包含是否相交与交点的对象 */
    static intersectionLineSegmentPlane(line_start: Float32Array, line_end: Float32Array, plane_root: Float32Array, plane_normal: Float32Array): {
        res: boolean;
        param?: undefined;
        pos?: undefined;
    } | {
        res: boolean;
        param: any;
        pos: any;
    };
    /** 判断两点是否在容差范围内相等 */
    static samePoint(p0: Float32Array, p1: Float32Array): boolean;
    /** 判断两向量是否在法线容差范围内相等 */
    static sameVector(v0: Float32Array, v1: Float32Array): boolean;
    /** 计算两点之间的欧氏距离 */
    static distance(p1: Float32Array, p2: Float32Array): number;
    /**
     * 根据原点、方向向量和距离值计算新点的坐标
     *
     * @param or - 原点坐标，长度为3的Float32Array数组，表示三维空间中的起始点(x, y, z)
     * @param dir - 方向向量，长度为3的Float32Array数组，表示移动方向(x, y, z)
     * @param va - 距离值，标量数值，表示沿方向向量移动的距离
     * @returns 返回一个新的Float32Array数组，包含计算后的新点坐标(x, y, z)
     */
    static distancePoint(or: Float32Array, dir: Float32Array, va: number): Float32Array;
    /**
     * 将三维空间中的点投影到直线上
     * @param point - 要投影的点坐标，长度为3的Float32Array数组，表示三维空间中的点(x, y, z)
     * @param origin - 直线上的参考点坐标，长度为3的Float32Array数组，表示直线上的起始点(x, y, z)
     * @param direction - 直线的方向向量，长度为3的Float32Array数组，表示直线的方向(x, y, z)
     * @returns 返回一个新的Float32Array数组，包含投影点的坐标(x, y, z)
     */
    static projectPointToLine(point: Float32Array, origin: Float32Array, direction: Float32Array): Float32Array;
    /**
     * 将三维空间中的点投影到直线上，并返回投影点位置和参数值
     * @param point - 要投影的点坐标，长度为3的Float32Array数组，表示三维空间中的点(x, y, z)
     * @param origin - 直线上的参考点坐标，长度为3的Float32Array数组，表示直线上的起始点(x, y, z)
     * @param direction - 直线的方向向量，长度为3的Float32Array数组，表示直线的方向(x, y, z)
     * @returns 返回一个对象，包含投影点坐标和投影参数
     *          point: 投影点坐标，长度为3的Float32Array数组
     *          param: 投影参数，表示投影点相对于直线起始点的位置参数
     */
    static projectPointToLineWithParam(point: Float32Array, origin: Float32Array, direction: Float32Array): {
        point: Float32Array;
        param: number;
    };
    /**
     * 将三维空间中的点投影到由两个端点定义的直线上
     *
     * @param point - 要投影的点坐标，长度为3的Float32Array数组，表示三维空间中的点(x, y, z)
     * @param lineStart - 直线的起始点坐标，长度为3的Float32Array数组，表示直线上的起始点(x, y, z)
     * @param lineEnd - 直线的结束点坐标，长度为3的Float32Array数组，表示直线上的结束点(x, y, z)
     * @returns 返回一个新的Float32Array数组，包含投影点的坐标(x, y, z)
    
     */
    static projectPointToLine1(point: Float32Array, lineStart: Float32Array, lineEnd: Float32Array): Float32Array;
    /**
     * 将点投影到平面上并返回投影点
     * @param point 待投影点
     * @param root 平面上一点
     * @param normal 平面法向
     */
    static projectPointToPlane(point: Float32Array, root: Float32Array, normal: Float32Array): Float32Array;
    /** 判断两个向量是否平行（考虑容差） */
    static isParallel(v1: Float32Array, v2: Float32Array): boolean;
    /** 判断两个向量是否垂直（考虑容差） */
    static isPerpendicular(v1: Float32Array, v2: Float32Array): boolean;
    /**
   * 计算三维空间中直线与平面的相交点
   *
   * @param line_point - 直线上的一个点坐标，长度为3的Float32Array数组，表示直线上的参考点(x, y, z)
   * @param line_dir - 直线的方向向量，长度为3的Float32Array数组，表示直线的方向(x, y, z)
   * @param plane_point - 平面上的一个点坐标，长度为3的Float32Array数组，表示平面上的参考点(x, y, z)
   * @param plane_dir - 平面的法向量，长度为3的Float32Array数组，表示垂直于平面的方向向量(x, y, z)
   * @returns 返回一个对象，包含相交结果信息
   *          res: 布尔值，表示是否有相交点 (true=有相交点, false=无相交点)
   *          param: 相交点在直线上的参数值 (仅当res为true时有效)
   *          pos: 相交点的坐标数组 (仅当res为true时有效)
   */
    static intersectionLinePlane(line_point: Float32Array, line_dir: Float32Array, plane_point: Float32Array, plane_dir: Float32Array): {
        res: boolean;
        param?: undefined;
        pos?: undefined;
    } | {
        res: boolean;
        param: number;
        pos: Float32Array;
    };
    /**
     * 计算多边形的法向量
     *
     * @param polygon - 多边形顶点数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
     * @returns 返回标准化后的法向量数组 [x, y, z]
     */
    static polygonNormal(polygon: Float32Array): Float32Array;
    /**
     * 将多边形的顶点顺序进行逆序排列
     *
     * @param polygon - 多边形顶点数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
     *                  函数会直接修改原数组，无需返回值
     */
    static inversePolygon(polygon: Float32Array): void;
    /**
     * 判断点是否在线段上
     *
     * @param point - 要检测的点坐标，长度为3的Float32Array数组 [x, y, z]
     * @param line_start - 线段的起始点坐标，长度为3的Float32Array数组 [x1, y1, z1]
     * @param line_end - 线段的结束点坐标，长度为3的Float32Array数组 [x2, y2, z2]
     * @returns 返回布尔值，true表示点在线段上，false表示点不在线段上
     *
     *  */
    static isPointInLineSegment(point: Float32Array, line_start: Float32Array, line_end: Float32Array): boolean;
    /**
     * 判断点是否在多边形的边界上（在XY平面上进行判断）
     *
     * @param point - 要检测的点坐标，长度为3的Float32Array数组 [x, y, z]
     * @param polygon_points - 多边形的所有顶点坐标数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
     * @param polygon_indexes - 多边形索引数组，用于定义多边形的各个子多边形
     *                         每个子多边形由一个数字n和n个索引组成，n表示该子多边形的顶点数量
     * @returns 返回布尔值，true表示点在多边形边界上，false表示点不在多边形边界上
     */
    static isPointOnPolygonXy(point: Float32Array, polygon_points: Float32Array, polygon_indexes: Int32Array): boolean;
    /**
   * 判断点是否在多边形内部（在XY平面上进行判断）
   *
   * @param point - 要检测的点坐标，长度为3的Float32Array数组 [x, y, z]
   * @param polygon - 多边形顶点数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
   * @returns 返回布尔值，true表示点在多边形内部，false表示点在多边形外部
   */
    static isPointInPolygonXy(point: Float32Array, polygon: Float32Array): boolean;
    /**
   * 根据参数生成环形上的点集
   *
   * @param origin - 环的中心点坐标，长度为3的Float32Array数组 [x, y, z]
   * @param x_axis - X轴方向向量，长度为3的Float32Array数组，表示环的X轴方向
   * @param y_axis - Y轴方向向量，长度为3的Float32Array数组，表示环的Y轴方向
   * @param paramList - 参数数组，包含角度参数值（弧度制）
   * @param length - 环的半径长度
   * @returns 返回一个Float32Array数组，包含所有生成点的坐标，格式为 [x1, y1, z1, x2, y2, z2, ...]
   */
    static createRingPoints(origin: Float32Array, x_axis: Float32Array, y_axis: Float32Array, paramList: Float32Array, length: number): Float32Array;
    /**
   * 计算点相对于直线上参考点的位置参数
   *
   * @param point - 要计算参数的点坐标，长度为3的Float32Array数组 [x, y, z]
   * @param origin - 直线上的参考点坐标，长度为3的Float32Array数组 [x0, y0, z0]
   * @param direction - 直线的方向向量，长度为3的Float32Array数组 [dx, dy, dz]
   * @returns 返回一个数值，表示点在直线上的参数值
   *          正值表示点在方向向量的同方向上，负值表示在反方向上
   */
    static lineParam(point: Float32Array, origin: Float32Array, direction: Float32Array): number;
    /**
   * 计算点相对于由两个端点定义的直线上的参数值
   *
   * @param point - 要计算参数的点坐标，长度为3的Float32Array数组 [x, y, z]
   * @param lineStart - 直线的起始点坐标，长度为3的Float32Array数组 [x1, y1, z1]
   * @param lineEnd - 直线的结束点坐标，长度为3的Float32Array数组 [x2, y2, z2]
   * @returns 返回一个数值，表示点在直线上的参数值
   *          正值表示点在方向向量的同方向上，负值表示在反方向上
   *  */
    static lineParam1(point: Float32Array, lineStart: Float32Array, lineEnd: Float32Array): number;
    /**
   * 计算两个向量之间的夹角
   *
   * @param v0 - 第一个向量，长度为3的Float32Array数组 [x, y, z]
   * @param v1 - 第二个向量，长度为3的Float32Array数组 [x, y, z]
   * @returns 返回两个向量之间的夹角，单位为弧度，范围在[0, π]之间
   */
    static angleBetween(v0: Float32Array, v1: Float32Array): number;
    /**
   * 计算两个向量之间的有向夹角，使用法向量确定角度方向
   *
   * @param v0 - 第一个向量，长度为3的Float32Array数组 [x, y, z]
   * @param v1 - 第二个向量，长度为3的Float32Array数组 [x, y, z]
   * @param normal - 法向量，用于确定角度的正负方向，长度为3的Float32Array数组 [x, y, z]
   * @returns 返回两个向量之间的有向夹角，单位为弧度，范围在[0, 2π]之间
   */
    static angleBetweenByNormal(v0: Float32Array, v1: Float32Array, normal: Float32Array): number;
    /**
   * 判断两个向量是否平行
   *
   * @param firstDirection - 第一个方向向量，长度为3的Float32Array数组 [x, y, z]
   * @param secondDirection - 第二个方向向量，长度为3的Float32Array数组 [x, y, z]
   * @returns 返回布尔值，true表示两向量平行，false表示不平行
   */
    static IsParallel(firstDirection: Float32Array, secondDirection: Float32Array): boolean;
    /**
   * 计算两个向量之间的包含角（锐角）
   *
   * @param v0 - 第一个向量，长度为3的Float32Array数组 [x, y, z]
   * @param v1 - 第二个向量，长度为3的Float32Array数组 [x, y, z]
   * @returns 返回两个向量之间的包含角，单位为弧度，范围在[0, π/2]之间
   */
    static includeAngleBetween(v0: Float32Array, v1: Float32Array): number;
    /**
   * 将三维点数组的顺序进行逆序排列
   *
   * @param points - 点数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
   * @returns 返回一个新的数组，包含逆序排列后的点坐标
   */
    static reversePoints(points: ArrayLike<number>): number[];
}
/**
 * 常用几何运算函数集合（双精度）
 *
 * 与 `GeometryOperators` 对应，但使用双精度数组 (`Float64Array`) 以提高数值精度。
 */
export declare class DGeometryOperators {
    /**
     * 计算两条无穷直线之间的最近点对（双精度版本）
     * @returns 若平行则返回 null，否则返回 { param0, param1, rp0, rp1 }
     */
    static closestPoint(p0: Float64Array, v0: Float64Array, p1: Float64Array, v1: Float64Array): any;
    /** 判断两点是否在双精度容差范围内相等 */
    static samePoint(p0: Float64Array, p1: Float64Array): boolean;
    /** 判断两点是否在指定容差内相等（双精度） */
    static samePointWithTolerance(p0: Float64Array, p1: Float64Array, tolerance: number): boolean;
    /** 判断两向量是否在双精度法线容差范围内相等 */
    static sameVector(v0: Float64Array, v1: Float64Array): boolean;
    /** 计算两点之间的欧氏距离（双精度） */
    static distance(p1: Float64Array, p2: Float64Array): number;
    /**
     * 根据原点、方向向量和距离值计算新点的坐标
     *
     * @param or - 原点坐标，长度为3的Float64Array数组，表示三维空间中的起始点(x, y, z)
     * @param dir - 方向向量，长度为3的Float64Array数组，表示移动方向(x, y, z)
     * @param va - 距离值，标量数值，表示沿方向向量移动的距离
     * @returns 返回一个新的Float64Array数组，包含计算后的新点坐标(x, y, z)
     */
    static distancePoint(or: Float64Array, dir: Float64Array, va: number): Float64Array;
    /** 将点投影到直线上并返回投影位置（双精度） */
    static projectPointToLine(point: Float64Array, origin: Float64Array, direction: Float64Array): Float64Array;
    /** 以线段端点表示的直线投影（双精度） */
    static projectPointToLine1(point: Float64Array, lineStart: Float64Array, lineEnd: Float64Array): Float64Array;
    /** 将点投影到直线上并返回投影点与参数（双精度） */
    static projectPointToLineWithParam(point: Float64Array, origin: Float64Array, direction: Float64Array): {
        point: Float64Array;
        param: number;
    };
    /** 将点投影到平面上并返回投影点（双精度） */
    static projectPointToPlane(point: Float64Array, root: Float64Array, normal: Float64Array): Float64Array;
    /** 计算两个向量之间的夹角（双精度） */
    static angleBetween(v0: Float64Array, v1: Float64Array): number;
    /**
  * 计算两个向量之间的有向夹角，使用法向量确定角度方向
  *
  * @param v0 - 第一个向量，长度为3的Float64Array数组 [x, y, z]
  * @param v1 - 第二个向量，长度为3的Float64Array数组 [x, y, z]
  * @param normal - 法向量，用于确定角度的正负方向，长度为3的Float64Array数组 [x, y, z]
  * @returns 返回两个向量之间的有向夹角，单位为弧度，范围在[0, 2π]之间
  */
    static angleBetweenByNormal(v0: Float64Array, v1: Float64Array, normal: Float64Array): number;
    /** 判断两个向量是否平行（双精度容差） */
    static isParallel(v1: Float64Array, v2: Float64Array): boolean;
    /** 判断两个向量是否垂直（双精度容差） */
    static isPerpendicular(v1: Float64Array, v2: Float64Array): boolean;
    /** 计算两条直线的交点（若存在唯一交点） */
    static intersectionLineLine(line0_p0: Float64Array, line0_p1: Float64Array, line1_p0: Float64Array, line1_p1: Float64Array): any;
    /** 与 intersectionLineLine 相似，但使用点+方向向量表示直线 */
    static intersectionLineLine1(line0_point: Float64Array, line0_direct: Float64Array, line1_point: Float64Array, line1_direct: Float64Array): any;
    /** 计算两条线段是否相交，若相交返回交点位置，否则返回 null */
    static intersectionLineSegmentLineSegment(line0_p0: Float64Array, line0_p1: Float64Array, line1_p0: Float64Array, line1_p1: Float64Array): any;
    /**
  * 计算三维空间中直线与平面的相交点
  *
  * @param line_point - 直线上的一个点坐标，长度为3的数组，表示直线上的参考点(x, y, z)
  * @param line_dir - 直线的方向向量，长度为3的F数组，表示直线的方向(x, y, z)
  * @param plane_point - 平面上的一个点坐标，长度为3的数组，表示平面上的参考点(x, y, z)
  * @param plane_dir - 平面的法向量，长度为3的数组，表示垂直于平面的方向向量(x, y, z)
  * @returns 返回一个对象，包含相交结果信息
  *          res: 布尔值，表示是否有相交点 (true=有相交点, false=无相交点)
  *          param: 相交点在直线上的参数值 (仅当res为true时有效)
  *          pos: 相交点的坐标数组 (仅当res为true时有效)
  */
    static intersectionLinePlane(line_point: Float64Array, line_dir: Float64Array, plane_point: Float64Array, plane_dir: Float64Array): {
        res: boolean;
        param?: undefined;
        pos?: undefined;
    } | {
        res: boolean;
        param: number;
        pos: Float64Array;
    };
    /** 计算线段与平面的交点，返回包含是否相交与交点的对象 */
    static intersectionLineSegmentPlane(line_start: Float64Array, line_end: Float64Array, plane_root: Float64Array, plane_normal: Float64Array): {
        res: boolean;
        param?: undefined;
        pos?: undefined;
    } | {
        res: boolean;
        param: any;
        pos: any;
    };
    /**
   * 计算多边形的法向量
   *
   * @param polygon - 多边形顶点数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
   * @returns 返回标准化后的法向量数组 [x, y, z]
   */
    static polygonNormal(polygon: Float64Array): Float64Array;
    /**
   * 将多边形的顶点顺序进行逆序排列
   *
   * @param polygon - 多边形顶点数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
   *                  函数会直接修改原数组，无需返回值
   */
    static inversePolygon(polygon: Float64Array): void;
    /**
   * 判断点是否在线段上
   *
   * @param point - 要检测的点坐标，长度为3的Float32Array数组 [x, y, z]
   * @param line_start - 线段的起始点坐标，长度为3的Float32Array数组 [x1, y1, z1]
   * @param line_end - 线段的结束点坐标，长度为3的Float32Array数组 [x2, y2, z2]
   * @returns 返回布尔值，true表示点在线段上，false表示点不在线段上
   *
   *  */
    static isPointInLineSegment(point: Float64Array, line_start: Float64Array, line_end: Float64Array): boolean;
    /**
   * 判断点是否在多边形的边界上（在XY平面上进行判断）
   *
   * @param point - 要检测的点坐标，长度为3的Float32Array数组 [x, y, z]
   * @param polygon_points - 多边形的所有顶点坐标数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
   * @param polygon_indexes - 多边形索引数组，用于定义多边形的各个子多边形
   *                         每个子多边形由一个数字n和n个索引组成，n表示该子多边形的顶点数量
   * @returns 返回布尔值，true表示点在多边形边界上，false表示点不在多边形边界上
   */
    static isPointOnPolygonXy(point: Float64Array, polygon_points: Float64Array, polygon_indexes: Float64Array): boolean;
    /**
  * 判断点是否在多边形内部（在XY平面上进行判断）
  *
  * @param point - 要检测的点坐标，长度为3的Float32Array数组 [x, y, z]
  * @param polygon - 多边形顶点数组，格式为 [x1, y1, z1, x2, y2, z2, ...]
  * @returns 返回布尔值，true表示点在多边形内部，false表示点在多边形外部
  */
    static isPointInPolygonXy(point: Float64Array, polygon: Float64Array): boolean;
    /**
  * 根据参数生成环形上的点集
  *
  * @param origin - 环的中心点坐标，长度为3的Float32Array数组 [x, y, z]
  * @param x_axis - X轴方向向量，长度为3的Float32Array数组，表示环的X轴方向
  * @param y_axis - Y轴方向向量，长度为3的Float32Array数组，表示环的Y轴方向
  * @param paramList - 参数数组，包含角度参数值（弧度制）
  * @param length - 环的半径长度
  * @returns 返回一个Float32Array数组，包含所有生成点的坐标，格式为 [x1, y1, z1, x2, y2, z2, ...]
  */
    static createRingPoints(origin: Float64Array, x_axis: Float64Array, y_axis: Float64Array, paramList: Float64Array, length: number): Float64Array;
    /**
  * 计算点相对于直线上参考点的位置参数
  *
  * @param point - 要计算参数的点坐标，长度为3的Float32Array数组 [x, y, z]
  * @param origin - 直线上的参考点坐标，长度为3的Float32Array数组 [x0, y0, z0]
  * @param direction - 直线的方向向量，长度为3的Float32Array数组 [dx, dy, dz]
  * @returns 返回一个数值，表示点在直线上的参数值
  *          正值表示点在方向向量的同方向上，负值表示在反方向上
  */
    static lineParam(point: Float64Array, origin: Float64Array, direction: Float64Array): number;
    /**
  * 计算点相对于由两个端点定义的直线上的参数值
  *
  * @param point - 要计算参数的点坐标，长度为3的Float32Array数组 [x, y, z]
  * @param lineStart - 直线的起始点坐标，长度为3的Float32Array数组 [x1, y1, z1]
  * @param lineEnd - 直线的结束点坐标，长度为3的Float32Array数组 [x2, y2, z2]
  * @returns 返回一个数值，表示点在直线上的参数值
  *          正值表示点在方向向量的同方向上，负值表示在反方向上
  *  */
    static lineParam1(point: Float64Array, lineStart: Float64Array, lineEnd: Float64Array): number;
    /**
     * 重构多边形
     * @param polygon
     * @param tolerance 容差
     * @returns
     */
    static arrangePolygon(polygon: Float64Array, tolerance: number): Float64Array;
    /**
   * 通过线段数组创建多段线集合
   *
   * @param points - 线段端点数组，格式为 [x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, ...]
   *                 每两个连续的点构成一个线段
   * @returns 返回一个List，包含多个Float64Array，每个数组表示一条连续的多段线
   */
    static createPolylinesBySegments(points: ArrayLike<number>): List<Float64Array>;
    /**
   * 计算两个双精度向量之间的包含角（锐角）
   *
   * @param v0 - 第一个双精度向量，长度为3的Float64Array数组 [x, y, z]
   * @param v1 - 第二个双精度向量，长度为3的Float64Array数组 [x, y, z]
   * @returns 返回两个向量之间的包含角，单位为弧度，范围在[0, π/2]之间
   */
    static includeAngleBetween(v0: Float64Array, v1: Float64Array): number;
    /**
   * 计算两个双精度向量之间的包含角（锐角）
   *
   * @param v0 - 第一个双精度向量，长度为3的Float64Array数组 [x, y, z]
   * @param v1 - 第二个双精度向量，长度为3的Float64Array数组 [x, y, z]
   * @returns 返回两个向量之间的包含角，单位为弧度，范围在[0, π/2]之间
   */
    static reversePoints(points: ArrayLike<number>): number[];
}