mxcad 1.0.210 → 1.0.211

package/dist/mxcad.d.ts

@@ -352,16 +352,32 @@ export declare class McDbObjectArray {
  * 表示三维点的对象。
  */
 export declare class McGePoint3d {
+	/**
+	 * 坐标系的原点
+	 * @example
+	 * ```ts
+	 * const origin = McGePoint3d.kOrigin;
+	 * ```
+	 * */
 	static kOrigin: McGePoint3d;
+	/** 内部实现对象 */
 	imp: any;
 	/**
 	 * 构造函数。
 	 * @param dX X 坐标。
 	 * @param dY Y 坐标。
 	 * @param dZ Z 坐标。
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d } from 'mxcad'
+	 *
+	 * const point = new McGePoint3d(20,10,0);
+	 * ```
 	 */
 	constructor(dX?: number | object, dY?: number, dZ?: number);
-	/**  得对应的three.js 向量
+	/**
+	 * 将当前对象的坐标信息转换为 THREE.Vector3 类的实例
+	 * @return THREE.Vector3实例对象
 	 * @example
 	 * ```ts
 	 * import { McGePoint3d } from "mxcad";
@@ -382,46 +398,76 @@ export declare class McGePoint3d {
 	*/
 	setFromVector3(val: THREE.Vector3): this;
 	/**
-	 * 复制对象的值
+	 * 复制点对象的值
+	 * @param val 点对象
+	 * @return 复制后的点对象
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d } from "mxcad"
+	 *
+	 * const point1 = new McGePoint3d(20,10,0);
+	 * const point2 = new McGePoint3d();
+	 * point2.copy(point1);
+	 * ```
 	 */
 	copy(val: McGePoint3d): this;
 	/**
 	 * 使用矩阵变换该点
 	 * @param leftSide 变换矩阵
+	 * @returns 变换后的点对象
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d, McGeVector3d, McGeMatrix3d } from "mxcad"
+	 *
+	 * const point = new McGePoint3d(20,10,0);
+	   let matrix = new McGeMatrix3d();
+	   matrix.setToTranslation(new McGeVector3d(10,10,0));//平移
+	   point.transformBy(matrix);
+	 * ```
 	 */
 	transformBy(leftSide: McGeMatrix3d): this;
 	/**
 	* 计算点加上向量后的新位置
 	* @param vec 向量
+	* @return 计算后的点对象
 	* @example
 	* ```ts
-	* import { McGePoint3d } from "mxcad";
+	* import { McGePoint3d, McGeVector3d } from "mxcad";
 	*
 	* const pt1 = new McGePoint3d(20,10,0);
-	* const pt2 = new McGePoint3d(50,20,0);
-	* const vec = pt1.addvec(pt2);
+	* const pt = pt1.clone().addvec(new McGeVector3d(10,10,0))
 	* ```
 	*/
 	addvec(vec: McGeVector3d): this;
+	/**
+	 * 计算点加上向量后的新位置
+	 * @param vec 向量
+	 * @return 计算后的点对象
+	 */
 	av(vec: McGeVector3d): this;
 	/**
 	 * 计算点减去向量后的新位置
 	 * @param vec 向量
+	 * @return 计算后的点对象
 	 * @example
 	 * ```ts
-	 * import { McGePoint3d } from "mxcad";
+	 * import { McGePoint3d, McGeVector3d } from "mxcad";
 	 *
 	 * const pt1 = new McGePoint3d(20,10,0);
-	 * const pt2 = new McGePoint3d(50,20,0);
-	 * const pt = pt1.clone().subvec(pt2);
-	 * console.log(pt1)
+	 * const pt = pt1.clone().subvec(new McGeVector3d(10,10,0));
 	 * ```
 	 */
 	subvec(vec: McGeVector3d): this;
+	/**
+	 * 计算点减去向量后的新位置
+	 * @param vec 向量
+	 * @return 计算后的点对象
+	 */
 	sv(vec: McGeVector3d): this;
 	/**
 	 * 返回两点相减后得到的一个新的向量
-	 * @param pt 三维点向量
+	 * @param pt 三维点对象
+	 * @return 三维点向量
 	 * @example
 	 * ```ts
 	 * import { McGePoint3d } from "mxcad";
@@ -434,7 +480,8 @@ export declare class McGePoint3d {
 	sub(pt: McGePoint3d): McGeVector3d;
 	/**
 	 * 计算两点距离
-	 * @param pnt 三维点向量
+	 * @param pnt 三维点对象
+	 * @return 两点距离
 	 * @example
 	 * ```ts
 	 * import { McGePoint3d } from "mxcad";
@@ -447,47 +494,158 @@ export declare class McGePoint3d {
 	distanceTo(pnt: McGePoint3d): number;
 	/**
 	* 判断两个点是否相等
+	* @param pnt 三维点对象
+	* @return 布尔值
+	* @example
+	* ```ts
+	* import { McGePoint3d } from "mxcad"
+	*
+	* const pt1 = new McGePoint3d(10,20,0);
+	* const pt2 = new McGePoint3d(10,10,0);
+	* const res = pt1.isEqualTo(pt2);
+	* console.log(res)//输出false
+	* ```
 	*/
 	isEqualTo(pnt: McGePoint3d): boolean;
 	/**
-	 * 刻隆一个对对象
+	 * 刻隆一个点对象
+	 * @return 三维点对象
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d } from "mxcad"
+	 *
+	 * const pt1 = new McGePoint3d(10,10,0);
+	 * const pt2 = pt1.clone();
+	 * ```
 	 */
 	clone(): McGePoint3d;
+	/**
+	 * 刻隆一个点对象
+	 * @return 三维点对象
+	 */
 	c(): McGePoint3d;
 	/**
-	 * X 坐标。
+	 * 获取或设置 X 坐标。
+	 * @param val X轴坐标值
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d } from "mxcad'
+	 *
+	 * const point = new McGePoint3d();
+	 * point.x = 10;
+	 * console.log(point.x)//输出10
+	 * ```
 	 */
 	get x(): number;
 	set x(val: number);
 	/**
-	 * Y 坐标。
+	 * 获取或设置 Y 坐标。
+	 * @param val Y轴坐标值
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d } from "mxcad'
+	 *
+	 * const point = new McGePoint3d();
+	 * point.y = 10;
+	 * console.log(point.y)//输出10
+	 * ```
 	 */
 	get y(): number;
 	set y(val: number);
 	/**
-	 * Z 坐标。
+	 *获取或设置 Z 坐标。
+	 * @param val Z轴坐标值
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d } from "mxcad'
+	 *
+	 * const point = new McGePoint3d();
+	 * point.z = 10;
+	 * console.log(point.z)//输出10
+	 * ```
 	 */
 	get z(): number;
 	set z(val: number);
 }
 /**
  * 表示三维向量的对象。
+ * @example
+ * ```ts
+ * //求失量与X轴的夹角
+ * const angle1 = vetT.angleTo2(McGeVector3d.McGeVector3d.kXAxis ,McGeVector3d.kNegateZAxis)
+ * ```
+ * ```ts
+ * //求出vetFx逆时针到vetT的角度
+ * const angle2 = vetFx.angleTo2(vetT, McGeVector3d.kZAxis)
+ * ```
+ * ```ts
+ * //判断向量vetT在向量VetFX的左边,还是在右边的调用
+ * const angle3 = vetFx.angleTo2(vetT, McGeVector3d.kZAxis);
+   if(angle >= 0.0 && angle <= PI ){
+	   //向量vetT在vetFX的左边.
+	} else {
+	  //向量vetT在vetFX的右边.
+	}
+   // 或
+   if (vetFX.dotProduct(vetT.perpVector()) < 0){
+	 //  vetFX在vetT的左边。
+   }
+ * ```
  */
 export declare class McGeVector3d {
-	/** X轴 */
+	/**
+	 * X轴单位向量, 指向正 X 轴方向
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad"
+	 *
+	 * const x_vec = McGeVector3d.kXAxis;
+	 * ```
+	 * */
 	static kXAxis: McGeVector3d;
-	/** Y轴 */
+	/**
+	 * Y轴单位向量, 指向正 Y 轴方向
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad"
+	 *
+	 * const y_vec = McGeVector3d.kYAxis;
+	 * ```
+	 */
 	static kYAxis: McGeVector3d;
-	/** Z轴 */
+	/**
+	* Z轴单位向量, 指向正 Z 轴方向
+	* @example
+	* ```ts
+	* import { McGeVector3d } from "mxcad"
+	*
+	* const y_vec = McGeVector3d.kZAxis;
+	* ```
+	 */
 	static kZAxis: McGeVector3d;
-	/** 取反z轴 */
+	/**
+	 * Z轴单位向量, 指向负 Z 轴方向
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad"
+	 *
+	 * const zNegate_vec = McGeVector3d.kNegateZAxis;
+	 * ```
+	 */
 	static kNegateZAxis: McGeVector3d;
+	/** 内部实现对象 */
 	imp: any;
 	/**
 	 * 构造函数。
 	 * @param dX X 坐标。
 	 * @param dY Y 坐标。
 	 * @param dZ Z 坐标。
+	 * @example
+	 * ```ts
+	 * import { MdGeVector3d } from "mxcad";
+	 *
+	 * const vec = new MdGeVector3d(20,10,0)
+	 * ```
 	 */
 	constructor(dX?: number | object, dY?: number, dZ?: number);
 	/** 转换为THREE.Vector3
@@ -502,12 +660,34 @@ export declare class McGeVector3d {
 	toVector3(): THREE.Vector3;
 	/**
 	 * 复制对象的值
+	 * @param val 三维向量对象
+	 * @return 复制后的三维向量对象
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad"
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const vec2 = new McGeVector3d();
+	 * vec2.copy(vec1);
+	 * ```
 	 */
 	copy(val: McGeVector3d): this;
 	/**
-	 * 刻隆一个对对象
+	 * 刻隆一个向量对象
+	 * @return 三维向量对象
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad"
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const vec2 = vec1.clone();
+	 * ```
 	 */
 	clone(): McGeVector3d;
+	/**
+	 * 刻隆一个向量对象
+	 * @return 三维向量对象
+	 */
 	c(): McGeVector3d;
 	/** 旋转
 	 * @param ang 旋转角度。
@@ -521,11 +701,29 @@ export declare class McGeVector3d {
 	 * ```
 	 *  */
 	rotateBy(ang: number, axis?: McGeVector3d): this;
-	/** 向量取反 */
+	/**
+	 * 向量取反
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec = new McGeVector3d(20,10,0);
+	 * vec_neg = vec.clone().negate()
+	 * ```
+	 * */
 	negate(): this;
-	/** 垂直的向量 */
+	/**
+	 * 垂直向量
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec = new McGeVector3d(20,10,0);
+	 * vec_perp = vec.clone().perpVector()
+	 * ```
+	 * */
 	perpVector(): this;
-	/** 计算角度
+	/** 计算两向量在[0, Pi]范围内所夹的角度
 	 * @example
 	 * ```ts
 	 * import { McGeVector3d } from "mxcad";
@@ -536,7 +734,7 @@ export declare class McGeVector3d {
 	 * ```
 	 * */
 	angleTo1(vec: McGeVector3d): number;
-	/** 计算角度
+	/** 计算两向量在[0, 2*Pi]范围内所夹的角度
 	 * @example
 	 * ```ts
 	 * import { McGeVector3d } from "mxcad";
@@ -546,7 +744,9 @@ export declare class McGeVector3d {
 	 * ```
 	 * */
 	angleTo2(vec: McGeVector3d, refVec?: McGeVector3d): number;
-	/** 归一化操作
+	/**
+	 * 向量归一化操作
+	 * @return 三维向量对象
 	 * @example
 	 * ```ts
 	 * import { McGeVector3d } from "mxcad";
@@ -556,32 +756,136 @@ export declare class McGeVector3d {
 	 * ```
 	 * */
 	normalize(): this;
-	/** 向量长度 */
+	/**
+	 * 获取向量长度
+	 * @return 向量长度
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const length = vec1.length();
+	 * ```
+	 * */
 	length(): number;
-	/** 是否为单位向量 */
+	/**
+	 * 检查当前向量是否为单位长度
+	 * @return 布尔值
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const res = vec1.isUnitLength();
+	 * console.log(res)//输出false
+	 * ```
+	 * */
 	isUnitLength(): boolean;
-	/** 是否为零向量 */
+	/**
+	 * 是否为零向量
+	 * @return 布尔值
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const res = vec1.isZeroLength();
+	 * console.log(res)//输出false
+	 * ```
+	 * */
 	isZeroLength(): boolean;
-	/** 点积 */
+	/**
+	 * 两向量的点积
+	 * @param vec 三维向量对象
+	 * @return 点积结果
+	 * @example
+	 ```ts
+	 //判断两个向量方向相同还是相反
+	  const db = vec1.dotProduct(vec2);
+	  if(db < 0 ){
+		  //向量返向.
+	  }
+	 // 两个向量点乘如果等于0,表示向量垂直。
+	 // 两个向量点乘如果等于1,表示向量方向完全向同。
+	 // 两个向量点乘如果等于-1,表示向量方向完全反向。
+	 ```
+	 * */
 	dotProduct(vec: McGeVector3d): number;
-	/** 交叉积 */
+	/**
+	 * 两向量的交叉积
+	 * @return 三维向量对象
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const vec2 = new McGeVector3d(10,10,0);
+	 * const vec = vec2.crossProduct(vec1)
+	 * ```
+	 * */
 	crossProduct(vec: McGeVector3d): McGeVector3d;
-	/** 判断比较向量是否相等 */
+	/**
+	 * 判断比较两个向量是否相等
+	 * @param vec 三维向量对象
+	 * @return 布尔值
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const vec2 = new McGeVector3d(10,10,0);
+	 * const res = vec1.isEqualTo(vec2)
+	 * ```
+	 * */
 	isEqualTo(vec: McGeVector3d): boolean;
-	/** 向量与某个值相乘 */
+	/**
+	 * 向量与某个值相乘，修改向量长度
+	 * @param val 数字
+	 * @return 三维向量对象
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d(20,10,0);
+	 * const vec = vec1.clone().normalize().mult(20)
+	 * ```
+	 * */
 	mult(val: number): this;
 	/**
-	 * X 坐标。
+	 * 获取或设置向量 X 坐标。
+	 * @param val x轴坐标
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d();
+	 * vec1.x = 10;
+	 * ```
 	 */
 	get x(): number;
 	set x(val: number);
 	/**
-	 * Y 坐标。
+	 * 获取或设置向量 Y 坐标。
+	 * @param val y轴坐标
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d();
+	 * vec1.y = 10;
+	 * ```
 	 */
 	get y(): number;
 	set y(val: number);
 	/**
-	 * Z 坐标。
+	 * 获取或设置向量 Z 坐标。
+	 * @param val z轴坐标
+	 * @example
+	 * ```ts
+	 * import { McGeVector3d } from "mxcad";
+	 *
+	 * const vec1 = new McGeVector3d();
+	 * vec1.z = 0;
+	 * ```
 	 */
 	get z(): number;
 	set z(val: number);
@@ -595,58 +899,129 @@ export declare class McGeMatrix3d {
 	/**
 	 * 构造函数。
 	 * @param imp 内部实现对象
+	 * @example
+	 * ```ts
+	 * import { McGeMatrix3d } from "mxcad"
+	 *
+	 * const matrix = new McGeMatrix3d()
+	 * ```
 	 */
 	constructor(imp?: object);
 	/**
 	 * 复制对象的值
+	 * @param val 三维矩阵对象
+	 * @return 复制后的三维矩阵对象
+	 * ```ts
+	 * // matrix1 一个三维矩阵对象
+	 * const matrix = new McGeMatrix3d();
+	 * matrix.copy(matrix1)
+	 * ```
 	 */
 	copy(val: McGeMatrix3d): this;
 	/**
-	 * 刻隆一个对对象
+	 * 刻隆一个三维矩阵对象
+	 * @return 三维矩阵对象
+	 * @example
+	 * ```ts
+	 * // matrix1 一个三维矩阵对象
+	 * const matrix = matrix1.clone()
+	 * ```
 	 */
 	clone(): McGeMatrix3d;
 	/**
 	 * 将矩阵设置为单位矩阵。
+	 * @example
+	 * ```ts
+	 * // matrix 表示一个三维矩阵对象
+	 * matrix.setToIdentity()
+	 * ```
 	 */
 	setToIdentity(): this;
 	/**
 	 * 左乘指定的矩阵。
 	 * @param leftSide 左侧矩阵。
+	 * @return 返回左乘后的矩阵
+	 * @example
+	 * ```ts
+	 * // matrix1 表示一个三维矩阵对象
+	 * const matrix = new McGeMatrix3d()
+	 * matrix.preMultBy(matrix1);
+	 * ```
 	 */
 	preMultBy(leftSide: McGeMatrix3d): this;
 	/**
 	 * 右乘指定的矩阵。
-	 * @param rightSide 右侧矩阵。
+	 * @return 返回右乘后的矩阵
+	 * @example
+	 * ```ts
+	 * // matrix1 表示一个三维矩阵对象
+	 * const matrix = new McGeMatrix3d()
+	 * matrix.postMultBy(matrix1);
+	 * ```
 	 */
 	postMultBy(rightSide: McGeMatrix3d): this;
 	/**
 	 * 将矩阵设置为两个矩阵的乘积。
 	 * @param mat1 第一个矩阵。
 	 * @param mat2 第二个矩阵。
+	 * @example
+	 * ```ts
+	 * // matrix1 matrix2 表示两个三维矩阵对象
+	 * const matrix = new McGeMatrix3d()
+	 * matrix.setToProduct(matrix1, matrix2);
+	 * ```
 	 */
 	setToProduct(mat1: McGeMatrix3d, mat2: McGeMatrix3d): this;
 	/**
 	 * 求矩阵的逆矩阵。
+	 * @example
+	 * ```ts
+	 * // matrix表示一个三维矩阵对象
+	 * const mat_invert = matrix.clone().invert();
+	 * ```
 	 */
 	invert(): this;
 	/**
 	 * 判断矩阵是否为奇异矩阵。
 	 * @returns 如果是奇异矩阵返回 true，否则返回 false。
+	 * @example
+	 * ```ts
+	 * // matrix表示一个三维矩阵对象
+	 * const res = matrix.isSingular();
+	 * console.log(res)
+	 * ```
 	 */
 	isSingular(): boolean;
 	/**
 	 * 将矩阵转置。
+	 * @example
+	 * ```ts
+	 * // matrix表示一个三维矩阵对象
+	 * const mst_trs = matrix.clone().transposeIt();
+	 * ```
 	 */
 	transposeIt(): this;
 	/**
 	 * 判断矩阵是否与指定的矩阵相等。
 	 * @param mat 指定的矩阵。
 	 * @returns 如果相等返回 true，否则返回 false。
+	 * @example
+	 * ```ts
+	 * // matrix1 matrix2 表示两个三维矩阵对象
+	 * const res = matrix1.isEqualTo(matrix2);
+	 * console.log(res)
+	 * ```
 	 */
 	isEqualTo(mat: McGeMatrix3d): boolean;
 	/**
 	 * 求矩阵的行列式。
 	 * @returns 矩阵的行列式。
+	 * @example
+	 * ```ts
+	 * // matrix 表示一个三维矩阵对象
+	 * const detNum = matrix.det();
+	 * console.log(detNum)
+	 * ```
 	 */
 	det(): number;
 	/**
@@ -655,6 +1030,13 @@ export declare class McGeMatrix3d {
 	 * @param xAxis X 轴向量。
 	 * @param yAxis Y 轴向量。
 	 * @param zAxis Z 轴向量。
+	 * @example
+	 * ```ts
+	 * import { McGeMatrix3d , McGePoint3d, McGeVector3d} from "mxcad"
+	 *
+	 * const m1 = new McGeMatrix3d()
+	 * m1.setCoordSystem(new McGePoint3d(), new McGeVector3d(), new McGeVector3d(), new McGeVector3d())
+	 * ```
 	 */
 	setCoordSystem(origin: McGePoint3d, xAxis: McGeVector3d, yAxis: McGeVector3d, zAxis: McGeVector3d): this;
 	/**
@@ -707,8 +1089,8 @@ export declare class McGeMatrix3d {
    * @example
    * ```ts
    *import { McGeMatrix3d, McDbEntity } from "mxcad";
-
-	let matrix = new McGeMatrix3d();
+  
+	const matrix = new McGeMatrix3d();
 	const event = new McDbEntity();
 	matrix.setMirror(new McGeVector3d(0, 0, 0), new McGeVector3d(20, 0, 0));//平移
 	event.transformBy(matrix);
@@ -718,6 +1100,12 @@ export declare class McGeMatrix3d {
 	/**
 	 * 获取矩阵的缩放因子。
 	 * @returns 矩阵的缩放因子。
+	 * @example
+	 * ```ts
+	 * // matrix 表示一个三维矩阵对象
+	 * const scaleNum = matrix.scale()
+	 * console.log(scaleNum)
+	 * ```
 	 */
 	scale(): number;
 	/**
@@ -725,6 +1113,12 @@ export declare class McGeMatrix3d {
 	 * @param row 行索引。
 	 * @param col 列索引。
 	 * @returns 指定位置的元素值。
+	 * @example
+	 * ```ts
+	 * // matrix 表示一个三维矩阵对象
+	 * const data = matrix.getData(2,3)
+	 * console.log(data)
+	 * ```
 	 */
 	getData(row: number, col: number): number;
 }
@@ -732,35 +1126,138 @@ export declare class McGeMatrix3d {
  * 整数数组
  */
 export declare class McGeLongArray {
+	/** 内部实现对象 */
 	imp: any;
 	/**
 	 * 构造函数。
+	 * @param imp 内部实现对象
+	 * @example
+	 * ```ts
+	 * import { McGeLongArray } from "mxcad"
+	 *
+	  // 创建一个新的 McGeLongArray 实例
+	  const myArray = new McGeLongArray();
+  
+	  // 通过传入一个对象初始化 McGeLongArray
+	  const initialValues = { data: [1, 2, 3, 4] };
+	  const myArray2 = new McGeLongArray(initialValues);
+	 * ```
 	 */
 	constructor(imp?: object);
 	/**
 	 * 复制对象的值
+	 * @param val 整数数组
+	 * @example
+	 * ```ts
+	 * import { McGeLongArray } from "mxcad"
+	 *
+	   const array1 = new McGeLongArray();
+	   const array2 = new McGeLongArray();
+	   array2.append(10);
+	   array2.append(20);
+  
+	   // 复制 array2 的值到 array1
+	   array1.copy(array2);
+	 * ```
 	 */
 	copy(val: McGeLongArray): this;
+	/**
+	 * 从 McObjectId 数组中复制值
+	 * @param aryId McObjectId 数组
+	 * @example
+	 * ```ts
+	 * //objectIdArray 为一个对象id数组
+	   const array = new McGeLongArray();
+	   array.copyFormAryId(objectIdArray);
+	 * ```
+	 */
 	copyFormAryId(aryId: McObjectId[]): this;
 	/**
-	* 添加一个值
+	* 向数组中添加一个值
+	* @param val 整数值
+	* @example
+	* ```ts
+	* import { McGeLongArray } from "mxcad";
+	*
+	  const array = new McGeLongArray();
+	  array.append(5);
+	  array.append(10)
+	* ```
 	*/
 	append(val: number): void;
 	/**
 	 * 返回数组长度
+	 * @return 数组长度
+	 * @example
+	 * ```ts
+	 * import { McGeLongArray } from "mxcad"
+	 *
+	   const array = new McGeLongArray();
+	   console.log(array.length()); // 输出: 0
+	 * ```
 	 */
 	length(): number;
 	/**
-	 * 得到数据元素的值
+	 * 根据数组索引得到数据元素的值
+	 * @param index 数组索引
+	 * @return 返回元素值
+	 * @example
+	 * ```ts
+	 * import { McGeLongArray } from "mxcad"
+	 *
+	   const array = new McGeLongArray();
+	   array.append(5);
+	   array.append(10);
+  
+	   console.log(array.at(0)); // 输出: 5
+	   console.log(array.at(1)); // 输出: 10
+	 * ```
 	 */
 	at(index: number): number;
 	/**
-	 * 设置数据元素的值
+	 * 通过数组索引设置数据元素的值
+	 * @param index 数组索引值
+	 * @param val 整数数值
+	 * @example
+	 * ```ts
+	 * import { McGeLongArray } from "mxcad"
+	 *
+	   const array = new McGeLongArray();
+	   array.append(5);
+	   array.append(10);
+  
+	   array.setAt(0, 15);
+	   console.log(array.at(0)); // 输出: 15
+	 * ```
 	 */
 	setAt(index: number, val: number): void;
+	/**
+	 * 清空数组
+	 * @example
+	 * ```ts
+	 * // array为整数数组
+	 * array.clear()
+	 * ```
+	 */
 	clear(): void;
 	/**
 	* 遍历数组
+	* @param call 回调函数
+	* @example
+	* ```ts
+	* import { McGeLongArray } from "mxcad"
+	*
+	  const array = new McGeLongArray();
+	  array.append(5);
+	  array.append(10);
+  
+	  array.forEach((val, index) => {
+		console.log(`Index ${index}: Value ${val}`);
+	  });
+	  // 输出:
+	  // Index 0: Value 5
+	  // Index 1: Value 10
+	* ```
 	*/
 	forEach(call: (val: number, index: number) => void): void;
 }
@@ -768,111 +1265,389 @@ export declare class McGeLongArray {
  * 表示字符串的数组
  */
 export declare class McGeStringArray {
+	/** 内部实现对象 */
 	imp: any;
 	/**
 	 * 构造函数。
+	 * @param imp 内部构造函数
+	 * @example
+	 * ```ts
+	 * import { McGeStringArray } from "mxcad";
+	 *
+	   // 创建一个新的 McGeStringArray 实例
+	   const myArray = new McGeStringArray();
+  
+	   // 通过传入一个对象初始化 McGeStringArray
+	   const initialValues = { data: ["apple", "banana", "orange"] };
+	   const myArray2 = new McGeStringArray(initialValues);
+	 * ```
 	 */
 	constructor(imp?: object);
 	/**
 	 * 复制对象的值
+	 * @example
+	 * ```ts
+	 * import { McGeStringArray } from "mxcad";
+	 *
+	   const array1 = new McGeStringArray();
+	   const array2 = new McGeStringArray();
+	   array2.append("apple");
+	   array2.append("banana");
+  
+	   // 复制 array2 的值到 array1
+	   array1.copy(array2);
+	 * ```
 	 */
 	copy(val: McGeStringArray): this;
 	/**
 	* 添加一个值
+	* @param val 字符串
+	* @example
+	* ```ts
+	* import { McGeStringArray } from "mxcad";
+	*
+	* const array = new McGeStringArray();
+	  array.append("apple");
+	  array.append("banana");
+	* ```
 	*/
 	append(val: string): void;
 	/**
 	 * 返回数组长度
+	 * @return 数组长度
+	 * @example
+	 * ```ts
+	 * import { McGeStringArray } from "mxcad";
+	 *
+	 * const array = new McGeStringArray();
+	 * console.log(array.length()); // 输出: 0
+	 * ```
 	 */
 	length(): number;
 	/**
-	 * 得到数据元素的值
+	 * 根据数组索引得到数据元素的值
+	 * @param index 数组索引
+	 * @return 字符串
+	 * @example
+	 * ```ts
+	 * import { McGeStringArray } from "mxcad";
+	 *
+	   const array = new McGeStringArray();
+	   array.append("apple");
+	   array.append("banana");
+  
+	   console.log(array.at(0)); // 输出: "apple"
+	   console.log(array.at(1)); // 输出: "banana"
+	 * ```
 	 */
 	at(index: number, decodeFromGb2312?: boolean): string;
 	/**
-	 * 设置数据元素的值
+	 * 通过数组索引设置数据元素的值
+	 * @param index 数组索引
+	 * @param val 字符串
+	 * @example
+	 * ```ts
+	 * import { McGeStringArray } from "mxcad";
+	 *
+	   const array = new McGeStringArray();
+	   array.append("apple");
+	   array.append("banana");
+  
+	   array.setAt(0, "orange");
+	   console.log(array.at(0)); // 输出: "orange"
+	 * ```
 	 */
 	setAt(index: number, val: string, decodeFromGb2312?: boolean): void;
 	/**
 	 * 遍历数组
+	 * @param call 回调函数
+	 * @example
+	 * ```ts
+	 * import { McGeStringArray } from "mxcad";
+	 *
+	   const array = new McGeStringArray();
+	   array.append("apple");
+	   array.append("banana");
+  
+	   array.forEach((val, index) => {
+		 console.log(`Index ${index}: Value ${val}`);
+	   });
+	   // 输出:
+	   // Index 0: Value apple
+	   // Index 1: Value banana
+	 * ```
 	 */
 	forEach(call: (val: string, index: number) => void, decodeFromGb2312?: boolean): void;
-	/** 清空数组 */
+	/**
+	 * 清空数组
+	 * @example
+	 * ```ts
+	 * import { McGeStringArray } from "mxcad";
+	 *
+	   const array = new McGeStringArray();
+	   array.append("apple");
+	   array.append("banana");
+  
+	   array.clear();
+	   console.log(array.length()); // 输出: 0
+	 * ```
+	 * */
 	clear(): void;
 }
 /**
  * 表示三维点的数组
  */
 export declare class McGePoint3dArray {
+	/** 内部实现对象 */
 	imp: any;
 	/**
 	 * 构造函数。
+	 * @param imp 内部实现对象
+	 * @example
+	 * ```ts
+	 * import { McGePoint3dArray, McGePoint3d } from "mxcad";
+	 *
+	   // 创建一个新的 McGePoint3dArray 实例
+	   const myArray = new McGePoint3dArray();
+  
+	   // 通过传入一个对象初始化 McGePoint3dArray
+	   const initialValues = [
+		 new McGePoint3d({ x: 1, y: 2, z: 3 }),
+		 new McGePoint3d({ x: 4, y: 5, z: 6 }),
+	   ];
+	   const myArray2 = new McGePoint3dArray(initialValues);
+	 * ```
 	 */
 	constructor(imp?: object);
 	/**
 	 * 复制对象的值
+	 * @param val 三维点的数组
+	 * @example
+	 * ```ts
+	 * import { McGePoint3d, McGePoint3dArray } from "mxcad"
+	 *
+	   const array1 = new McGePoint3dArray();
+	   const array2 = new McGePoint3dArray();
+	   array2.append(new McGePoint3d({ x: 1, y: 2, z: 3 }));
+	   array2.append(new McGePoint3d({ x: 4, y: 5, z: 6 }));
+  
+	   // 复制 array2 的值到 array1
+	   array1.copy(array2);
+	 * ```
 	 */
 	copy(val: McGePoint3dArray | McGePoint3d[]): this;
 	/**
 	* 添加一个值
+	* @param val 三维点对象
+	* @example
+	* ```ts
+	* import { McGePoint3d, McGePoint3dArray } from "mxcad"
+	*
+	* const array = new McGePoint3dArray();
+	  array.append(new McGePoint3d({ x: 1, y: 2, z: 3 }));
+	  array.append(new McGePoint3d({ x: 4, y: 5, z: 6 }));
+	* ```
 	*/
 	append(val: McGePoint3d): void;
 	/**
 	 * 返回数组长度
+	 * @return 数组长度
+	 * @example
+	 * ```ts
+	 * import { McGePoint3dArray } from "mxcad"
+	 *const array = new McGePoint3dArray();
+	  console.log(array.length()); // 输出: 0
+	 * ```
 	 */
 	length(): number;
 	/**
 	 * 返回数组为空
+	 * @return 布尔值
+	 * @example
+	 * ```ts
+	 * import { McGePoint3dArray, McGePoint3d } from "mxcad"
+	   const array = new McGePoint3dArray();
+	   console.log(array.isEmpty()); // 输出: true
+  
+	   array.append(new McGePoint3d({ x: 1, y: 2, z: 3 }));
+	   console.log(array.isEmpty()); // 输出: false
+	 * ```
 	 */
 	isEmpty(): boolean;
 	/**
-	 * 得到数据元素的值
+	 * 根据数组索引值得到数据元素的值
+	 * @param index 数组索引
+	 * @example
+	 * ```ts
+	 * import { McGePoint3dArray, McGePoint3d } from "mxcad"
+	 *
+	   const array = new McGePoint3dArray();
+	   array.append(new McGePoint3d({ x: 1, y: 2, z: 3 }));
+	   array.append(new McGePoint3d({ x: 4, y: 5, z: 6 }));
+  
+	   const point = array.at(0);
+	   console.log(point); // 输出: McGePoint3d { x: 1, y: 2, z: 3 }
+	 * ```
 	 */
 	at(index: number): McGePoint3d;
 	/**
-	 * 设置数据元素的值
+	 * 通过数组索引设置数据元素的值
+	 * @param index 数组索引
+	 * @param val 三维点对象
+	 * @example
+	 * ```ts
+	 * import { McGePoint3dArray, McGePoint3d } from "mxcad"
+	 *
+	   const array = new McGePoint3dArray();
+	   array.append(new McGePoint3d({ x: 1, y: 2, z: 3 }));
+	   array.append(new McGePoint3d({ x: 4, y: 5, z: 6 }));
+  
+	   array.setAt(0, new McGePoint3d({ x: 7, y: 8, z: 9 }));
+	   console.log(array.at(0)); // 输出: McGePoint3d { x: 7, y: 8, z: 9 }
+	 * ```
 	 */
 	setAt(index: number, val: McGePoint3d): void;
-	/** 清空数组 */
+	/**
+	 * 清空数组
+	 * @example
+	 * ```ts
+	 * import { McGePoint3dArray, McGePoint3d } from "mxcad"
+	 *
+	   const array = new McGePoint3dArray();
+	   array.append(new McGePoint3d({ x: 1, y: 2, z: 3 }));
+	   array.append(new McGePoint3d({ x: 4, y: 5, z: 6 }));
+  
+	   array.clear();
+	   console.log(array.length()); // 输出: 0
+	 * ```
+	 * */
 	clear(): void;
 	/**
 	 * 遍历数组
+	 * @param call 回调函数
+	 * @example
+	 * ```ts
+	 * import { McGePoint3dArray, McGePoint3d } from "mxcad"
+	 *
+	   const array = new McGePoint3dArray();
+	   array.append(new McGePoint3d({ x: 1, y: 2, z: 3 }));
+	   array.append(new McGePoint3d({ x: 4, y: 5, z: 6 }));
+  
+	   array.forEach((point, index) => {
+		 console.log(`Index ${index}: Point ${point}`);
+	   });
+	   // 输出:
+	   // Index 0: Point McGePoint3d { x: 1, y: 2, z: 3 }
+	   // Index 1: Point McGePoint3d { x: 4, y: 5, z: 6 }
+	 * ```
 	 */
 	forEach(call: (val: McGePoint3d, index: number) => void): void;
 }
 /**
- * 整数数组
+ * 双精度浮点数数组
  */
 export declare class McGeDoubleArray {
+	/** 内部实现对象 */
 	imp: any;
 	/**
 	 * 构造函数。
+	 * @param imp 内部实现对象
+	 * @example
+	 * ```ts
+	 * import { McGeDoubleArray } from "mxcad"
+  
+	   const array = new McGeDoubleArray();
+	 * ```
 	 */
 	constructor(imp?: object);
 	/**
 	 * 复制对象的值
+	 * @param val 双精度浮点数数组
+	 * @example
+	 * ```ts
+	 * import { McGeDoubleArray } from "mxcad"
+	 *
+	  // array1 表示一个双精度浮点数数组
+	  const array2 = new McGeDoubleArray();
+	  array2.copy(array1);
+  
+	  // 现在array2与array1具有相同的值
+	 * ```
 	 */
 	copy(val: McGeDoubleArray): this;
 	/**
 	* 添加一个值
+	* @param val 双精度浮点数
+	* @example
+	* ```ts
+	* import { McGeDoubleArray } from "mxcad"
+	*
+	  // 创建数组实例
+	  const array = new McGeDoubleArray();
+	  array.append(3.14159);
+	* ```
 	*/
 	append(val: number): void;
 	/**
 	 * 返回数组长度
+	 * @return 数组长度
+	 * @example
+	 * ```ts
+	 * import { McGeDoubleArray } from "mxcad"
+  
+	   const array = new McGeDoubleArray();
+	   const length = array.length();//0
+	 * ```
 	 */
 	length(): number;
 	/**
-	 * 得到数据元素的值
+	 * 通过数组索引得到数据元素的值
+	 * @param index 数组索引
+	 * @example
+	 * ```ts
+	 * import { McGeDoubleArray } from "mxcad"
+  
+	   const array = new McGeDoubleArray();
+	   // 获取特定索引位置的值
+	   const value = array.at(2); // 假设索引为2的位置有值
+	 * ```
 	 */
 	at(index: number): number;
 	/**
-	 * 设置数据元素的值
+	 * 通过数组索引设置数据元素的值
+	 * @param 数组索引
+	 * @param val 双精度浮点数
+	 * @example
+	 * ```ts
+	 * import { McGeDoubleArray } from "mxcad"
+  
+	   const array = new McGeDoubleArray();
+	   array.setAt(1, 3.14159); // 将索引为1的位置的值设置为3.14159
+	 * ```
 	 */
 	setAt(index: number, val: number): void;
-	/** 清空数组 */
+	/**
+	 * 清空数组
+	 * @example
+	 * ```ts
+	 * // array 表示一个McGeDoubleArray数组
+	   array.clear();
+	 * ```
+	 * */
 	clear(): void;
 	/**
 	 * 遍历数组
+	 * @param call 回调函数
+	 * @example
+	 * ```ts
+	 * import { McGeDoubleArray } from "mxcad"
+  
+	   const array = new McGeDoubleArray();
+	   array.append(3.14159);
+	   array.forEach((val,index)=>{
+		 console.log(`Value at index ${index}: ${value}`);
+	   })
+	 * ```
 	 */
 	forEach(call: (val: number, index: number) => void): void;
 }
@@ -880,28 +1655,92 @@ export declare class McGeDoubleArray {
  * 范围对象
  */
 export declare class McGeBound {
-	/** 最小点 */
+	/**
+	 *  最小点
+	 * @example
+	 * ```ts
+	 * import { McGeBound, McGePoint3d } from "mxcad"
+	 *
+	  // 创建 McGeBound 实例
+	  const bound = new McGeBound();
+	  // 访问最小点属性并设置其值
+	  bound.minPoint = new McGePoint3d(0, 0, 0);
+	  ```
+	*/
 	minPoint: McGePoint3d;
-	/** 最大点 */
+	/**
+	 * 最大点
+	 * @example
+	 * ```ts
+	 * import { McGeBound, McGePoint3d } from "mxcad"
+	 *
+	  // 创建 McGeBound 实例
+	  const bound = new McGeBound();
+	  // 访问最大点属性并设置其值
+	  bound.maxPoint = new McGePoint3d(20, 10, 0);
+	  ```
+	 * */
 	maxPoint: McGePoint3d;
-	/** 是否有效 */
+	/**
+	 * 是否有效
+	 * @example
+	 * ```ts
+	 * import { McGeBound } from "mxcad"
+	 *
+	  // 创建 McGeBound 实例
+	  const bound = new McGeBound();
+	  // 访问是否有效属性并设置其值
+	  bound.isValid = true;;
+	  ```
+	 * */
 	isValid: boolean;
 	/**
 	 * 构造函数。
+	 * @param pts 三维点数组
+	 * @example
+	 * ```ts
+	 * import { McGeBound, McGePoint3d } from "mxcad"
+	 *
+	   const points = [new McGePoint3d(1, 2, 3), new McGePoint3d(4, 5, 6)];
+	   const bound = new McGeBound(points);
+	 * ```
 	 */
 	constructor(pts?: McGePoint3dArray | McGePoint3d[]);
 	/**
 	 * 添加一个点
 	 * @param pt 三维点对象
+	 * @example
+	 * ```ts
+	 * import { McGeBound, McGePoint3d } from "mxcad"
+	 * // 创建 McGeBound 实例
+	   const bound = new McGeBound();
+	   // 添加一个点到边界
+	   const point = new McGePoint3d(3, 4, 5);
+	   bound.addPoint(point);
+	 * ```
 	 */
 	addPoint(pt: McGePoint3d): void;
 	/**
 	 * 添加一组点
 	 * @param pts 三维点对象数组
+	 * @example
+	 * ```ts
+	 * import { McGeBound } from "mxcad"
+	 *
+	   // 创建 McGeBound 实例
+	   const bound = new McGeBound();
+  
+	   // 创建一组点
+	   const points = [new McGePoint3d(1, 2, 3), new McGePoint3d(4, 5, 6), new McGePoint3d(7, 8, 9)];
+  
+	   // 添加一组点到边界
+	   bound.addPoints(points);
+	 * ```
 	 */
 	addPoints(pts: McGePoint3dArray | McGePoint3d[]): void;
 }
-declare class MxCoordConvertType {
+/** 坐标转换类型 */
+export declare class MxCoordConvertType {
 	/** 文档坐标转cad坐标
 	 * @param pt 三维点的对象
 	 * @returns 三维点的对象
@@ -976,6 +1815,7 @@ declare class MxCoordConvertType {
 	*/
 	cad2doc2(x: number, y: number, z: number): THREE.Vector3;
 }
+/** 提供坐标转换方法 */
 export declare let MxCoordConvert: MxCoordConvertType;
 export declare function getFilterImp(filter?: MxCADResbuf | null): any;
 /**
@@ -4794,18 +5634,36 @@ export declare enum ColorIndexType {
 	kBylayer = 256
 }
 export type ConstructorArguments<T> = T extends new (...args: infer U) => any ? U : never;
+/**
+ * McCmColor的JSON版本
+ */
 export type McCmColorJSON = ExcludePropertiesContainingThisType<McCmColor, Function>;
+/** THREE.Color 构造函数参数类型组成的元组：字符串、数字、THREE.Color */
 export type THREEColorArgs = [
 	(string | number | THREE.Color)
 ] | ConstructorArguments<typeof THREE.Color> | [
 ];
+/** 用于指定在创建颜色时可以接受的不同类型的参数形式 */
 export type CreateColorArgs = THREEColorArgs | [
 	(Partial<McCmColorJSON> | McCmColor)
 ];
+/**
+ * 获取颜色工具
+ * @param ages 颜色参数
+ * @returns THREE.Color
+ * */
 export declare const getColorUtils: (...ages: THREEColorArgs) => THREE.Color;
-/** 创建颜色对象 */
+/**
+ * 创建颜色对象
+ * @param ages 颜色参数类型
+ * @returns 颜色对象
+ */
 export declare const createMcCmColor: (...ages: CreateColorArgs) => McCmColor;
-/** 设置颜色 */
+/**
+ * 设置颜色
+ * @param mcCmColor 颜色对象
+ * @param ages 颜色参数类型
+ */
 export declare const setMcCmColor: (mcCmColor: McCmColor, ...ages: CreateColorArgs) => void;
 /**
  * 枚举 Fetch 属性类型
@@ -5081,6 +5939,8 @@ export declare class McObject {
 	 * @param sBlkName 插入的图块的块名
 	 * @param isWorkThread 是否使用工作线程打开文件，默认为 true
 	 * @param fetchAttributes 1：EMSCRIPTEN_FETCH_LOAD_TO_MEMORY,把图纸数据加载内存中，0:EMSCRIPTEN_FETCH_LOAD_TO_MEMORY | EMSCRIPTEN_FETCH_PERSIST_FILE | EMSCRIPTEN_FETCH_APPEND，把图纸数据加到IndexedDB。
+	 * @param isUpdataInsertBlock 是否更新已经存在的块，默认不会更新
+	 * @param isUpdataSameNameBlock 是插入块的过程中，如果发现原数据库已经相同名称的块，是否也一同更新，默认不会更新
 	 * @example
 	 * ```ts
 	 * import { MxCpp, McObject } from "mxcad"
@@ -5088,7 +5948,7 @@ export declare class McObject {
 	 * const blkrecId = await mxcad.insertBlock("./blkrec.mxweb", "sBlkName");
 	 * ```
 	*/
-	insertBlock(sFileUrl: string, sBlkName: string, isWorkThread?: boolean, fetchAttributes?: number): Promise<McObjectId>;
+	insertBlock(sFileUrl: string, sBlkName: string, isWorkThread?: boolean, fetchAttributes?: number, isUpdataInsertBlock?: boolean, isUpdataSameNameBlock?: boolean): Promise<McObjectId>;
 	/**
 	 * 获取当前文件名
 	 * @returns 当前文件名
@@ -6728,6 +7588,8 @@ export interface MxCadConfig {
 	multipleSelect?: boolean;
 }
 /** 创建MxCad实例
+ * @param config 参数配置
+ * @param mxcadobj 对象
  * @example
  * //通过创建实例实现图纸展示以下基于vite打包工具
  * ```ts
@@ -6747,14 +7609,37 @@ export declare const createMxCad: (config?: MxCadConfig, mxcadobj?: McObject) =>
  * @param color 文字颜色
  */
 export declare function drawText(): Promise<McObjectId | undefined>;
+/**
+ * 绘圆
+ */
 export declare function drawCircle(): Promise<McObjectId | undefined>;
+/**
+ * 绘直线
+ */
 export declare function drawLine(): Promise<void>;
+/**
+ * 绘多行文本
+ */
 export declare function drawMText(): Promise<McObjectId | undefined>;
+/** 绘多义线 */
 export declare function drawPolyLine(): Promise<void>;
+/** 绘制正多边形 */
 export declare function drawPolygon(): Promise<void>;
+/**
+ * 绘制圆弧
+ */
 export declare function drawArc(): Promise<void>;
+/**
+ * 绘制椭圆或椭圆弧
+ */
 export declare function drawEllipticalArc(): Promise<McObjectId | undefined>;
+/**
+ * 删除对象
+ */
 export declare function Mx_Erase(): Promise<void>;
+/**
+ * 绘制矩形
+ */
 export declare const drawRectang: () => Promise<void>;
 declare const getWasmURL: (wasmURL: string, baseURL?: string | URL) => string;
 export type EventType = string | symbol;
@@ -10646,6 +11531,7 @@ export declare class MxCAD3DObject {
 	setCustomClipPlaneReverse(): void;
 	setCustomClipPlaneDirection(x: number, y: number, z: number): void;
 	displaySymbolText(theSymbol: MxNewMx3dSymbolText): void;
+	displayDimension(theDimension: MxNewMx3dDimObject): void;
 	addModelTexture(theFileName: string): void;
 	removeModelTexture(): void;
 	setGradientBgColor(theColor1: MxNewMx3dGeColor, theColor2: MxNewMx3dGeColor, theMethod: MdGe.MxGradientFillMethod): void;
@@ -10721,6 +11607,12 @@ export declare class MxNewMx3dSymbolObject extends MxNewMx3dBaseObject {
 export declare class MxNewMx3dAlgoObject extends MxNewMx3dBaseObject {
 	constructor(p?: object);
 }
+/**
+ * 样式基类
+ */
+export declare class MxNewMx3dAspectObject extends MxNewMx3dBaseObject {
+	constructor(p?: object);
+}
 /**
  * 数学几何基类
  */
@@ -10826,76 +11718,57 @@ export declare class MxNewMx3dGeDir extends MxNewMx3dGeObject {
 	Transform(theT: MxNewMx3dGeTrsf): void;
 	Transformed(theT: MxNewMx3dGeTrsf): MxNewMx3dGeDir;
 }
-export declare class MxNewMx3dGeEllipse extends MxNewMx3dGeConic {
-	constructor(A2: MxNewMx3dGeCSYSR, MajorRadius: number, MinorRadius: number);
-	TransformedParameter(U: number, T: MxNewMx3dGeTrsf): number;
-	ParametricTransformation(T: MxNewMx3dGeTrsf): number;
-	Reversed(): MxNewMx3dGeCircle;
-	Period(): number;
-	Value(U: number): MxNewMx3dGePoint;
+export declare class MxNewMx3dGeEllipse extends MxNewMx3dGeObject {
+	constructor();
+	constructor(theA2: MxNewMx3dGeCSYSR, theMajorRadius: number, theMinorRadius: number);
 	SetAxis(theA1: MxNewMx3dGeAxis): void;
 	SetLocation(theP: MxNewMx3dGePoint): void;
+	SetMajorRadius(theMajorRadius: number): void;
+	SetMinorRadius(theMinorRadius: number): void;
 	SetPosition(theA2: MxNewMx3dGeCSYSR): void;
+	Area(): number;
 	Axis(): MxNewMx3dGeAxis;
-	Location(): MxNewMx3dGePoint;
-	Position(): MxNewMx3dGeCSYSR;
-	XAxis(): MxNewMx3dGeAxis;
-	YAxis(): MxNewMx3dGeAxis;
-	Reverse(): void;
-	Continuity(): MdGe.MxGAShapeEnum;
-	IsCN(N: number): boolean;
-	SetMajorRadius(MajorRadius: number): void;
-	SetMinorRadius(MinorRadius: number): void;
-	ReversedParameter(U: number): number;
 	Directrix1(): MxNewMx3dGeAxis;
 	Directrix2(): MxNewMx3dGeAxis;
 	Eccentricity(): number;
 	Focal(): number;
 	Focus1(): MxNewMx3dGePoint;
 	Focus2(): MxNewMx3dGePoint;
+	Location(): MxNewMx3dGePoint;
 	MajorRadius(): number;
 	MinorRadius(): number;
 	Parameter(): number;
-	FirstParameter(): number;
-	LastParameter(): number;
-	IsClosed(): boolean;
-	IsPeriodic(): boolean;
-	D0(U: number, P: MxNewMx3dGePoint): void;
-	D1(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec): void;
-	D2(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec, V2: MxNewMx3dGeVec): void;
-	D3(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec, V2: MxNewMx3dGeVec, V3: MxNewMx3dGeVec): void;
-	DN(U: number, N: number): MxNewMx3dGeVec;
-	Transform(T: MxNewMx3dGeTrsf): void;
-	Edge(p1: number, p2: number): MxNewMx3dShapeEdge;
-	Wire(): MxNewMx3dShapeWire;
+	Position(): MxNewMx3dGeCSYSR;
+	XAxis(): MxNewMx3dGeAxis;
+	YAxis(): MxNewMx3dGeAxis;
+	MirrorByPoint(theP: MxNewMx3dGePoint): void;
+	MirroredByPoint(theP: MxNewMx3dGePoint): MxNewMx3dGeEllipse;
+	MirrorByAxis(theA1: MxNewMx3dGeAxis): void;
+	MirroredByAxis(theA1: MxNewMx3dGeAxis): MxNewMx3dGeEllipse;
+	MirrorByCSYSR(theA2: MxNewMx3dGeCSYSR): void;
+	MirroredByCSYSR(theA2: MxNewMx3dGeCSYSR): MxNewMx3dGeEllipse;
+	Rotate(theA1: MxNewMx3dGeAxis, theAng: number): void;
+	Rotated(theA1: MxNewMx3dGeAxis, theAng: number): MxNewMx3dGeEllipse;
+	Scale(theP: MxNewMx3dGePoint, theS: number): void;
+	Scaled(theP: MxNewMx3dGePoint, theS: number): MxNewMx3dGeEllipse;
+	Transform(theT: MxNewMx3dGeTrsf): void;
+	Transformed(theT: MxNewMx3dGeTrsf): MxNewMx3dGeEllipse;
+	TranslateByVec(theV: MxNewMx3dGeVec): void;
+	TranslatedByVec(theV: MxNewMx3dGeVec): MxNewMx3dGeEllipse;
+	TranslateBy2Points(theP1: MxNewMx3dGePoint, theP2: MxNewMx3dGePoint): void;
+	TranslatedBy2Points(theP1: MxNewMx3dGePoint, theP2: MxNewMx3dGePoint): MxNewMx3dGeEllipse;
 }
-export declare class MxNewMx3dGeHyperbola extends MxNewMx3dGeConic {
-	constructor(A2: MxNewMx3dGeCSYSR, MajorRadius: number, MinorRadius: number);
-	TransformedParameter(U: number, T: MxNewMx3dGeTrsf): number;
-	ParametricTransformation(T: MxNewMx3dGeTrsf): number;
-	Reversed(): MxNewMx3dGeCircle;
-	Period(): number;
-	Value(U: number): MxNewMx3dGePoint;
+export declare class MxNewMx3dGeHyperbola extends MxNewMx3dGeObject {
+	constructor();
+	constructor(theA2: MxNewMx3dGeCSYSR, theMajorRadius: number, theMinorRadius: number);
 	SetAxis(theA1: MxNewMx3dGeAxis): void;
 	SetLocation(theP: MxNewMx3dGePoint): void;
+	SetMajorRadius(theMajorRadius: number): void;
+	SetMinorRadius(theMinorRadius: number): void;
 	SetPosition(theA2: MxNewMx3dGeCSYSR): void;
-	Axis(): MxNewMx3dGeAxis;
-	Location(): MxNewMx3dGePoint;
-	Position(): MxNewMx3dGeCSYSR;
-	XAxis(): MxNewMx3dGeAxis;
-	YAxis(): MxNewMx3dGeAxis;
-	Reverse(): void;
-	Continuity(): MdGe.MxGAShapeEnum;
-	IsCN(N: number): boolean;
-	SetMajorRadius(MajorRadius: number): void;
-	SetMinorRadius(MinorRadius: number): void;
-	ReversedParameter(U: number): number;
-	FirstParameter(): number;
-	LastParameter(): number;
-	IsClosed(): boolean;
-	IsPeriodic(): boolean;
 	Asymptote1(): MxNewMx3dGeAxis;
 	Asymptote2(): MxNewMx3dGeAxis;
+	Axis(): MxNewMx3dGeAxis;
 	ConjugateBranch1(): MxNewMx3dGeHyperbola;
 	ConjugateBranch2(): MxNewMx3dGeHyperbola;
 	Directrix1(): MxNewMx3dGeAxis;
@@ -10904,17 +11777,30 @@ export declare class MxNewMx3dGeHyperbola extends MxNewMx3dGeConic {
 	Focal(): number;
 	Focus1(): MxNewMx3dGePoint;
 	Focus2(): MxNewMx3dGePoint;
+	Location(): MxNewMx3dGePoint;
 	MajorRadius(): number;
 	MinorRadius(): number;
 	OtherBranch(): MxNewMx3dGeHyperbola;
 	Parameter(): number;
-	D0(U: number, P: MxNewMx3dGePoint): void;
-	D1(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec): void;
-	D2(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec, V2: MxNewMx3dGeVec): void;
-	D3(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec, V2: MxNewMx3dGeVec, V3: MxNewMx3dGeVec): void;
-	DN(U: number, N: number): MxNewMx3dGeVec;
-	Transform(T: MxNewMx3dGeTrsf): void;
-	Edge(p1: number, p2: number): MxNewMx3dShapeEdge;
+	Position(): MxNewMx3dGeCSYSR;
+	XAxis(): MxNewMx3dGeAxis;
+	YAxis(): MxNewMx3dGeAxis;
+	MirrorByPoint(theP: MxNewMx3dGePoint): void;
+	MirroredByPoint(theP: MxNewMx3dGePoint): MxNewMx3dGeHyperbola;
+	MirrorByAxis(theA1: MxNewMx3dGeAxis): void;
+	MirroredByAxis(theA1: MxNewMx3dGeAxis): MxNewMx3dGeHyperbola;
+	MirrorByCSYSR(theA2: MxNewMx3dGeCSYSR): void;
+	MirroredByCSYSR(theA2: MxNewMx3dGeCSYSR): MxNewMx3dGeHyperbola;
+	Rotate(theA1: MxNewMx3dGeAxis, theAng: number): void;
+	Rotated(theA1: MxNewMx3dGeAxis, theAng: number): MxNewMx3dGeHyperbola;
+	Scale(theP: MxNewMx3dGePoint, theS: number): void;
+	Scaled(theP: MxNewMx3dGePoint, theS: number): MxNewMx3dGeHyperbola;
+	Transform(theT: MxNewMx3dGeTrsf): void;
+	Transformed(theT: MxNewMx3dGeTrsf): MxNewMx3dGeHyperbola;
+	TranslateByVec(theV: MxNewMx3dGeVec): void;
+	TranslatedByVec(theV: MxNewMx3dGeVec): MxNewMx3dGeHyperbola;
+	TranslateBy2Points(theP1: MxNewMx3dGePoint, theP2: MxNewMx3dGePoint): void;
+	TranslatedBy2Points(theP1: MxNewMx3dGePoint, theP2: MxNewMx3dGePoint): MxNewMx3dGeHyperbola;
 }
 export declare class MxNewMx3dGeVec extends MxNewMx3dGeObject {
 	constructor();
@@ -11026,40 +11912,40 @@ export declare class MxNewMx3dGeBox extends MxNewMx3dGeObject {
 	constructor(Axes: MxNewMx3dGeCSYSR, dx: number, dy: number, dz: number);
 	Shape(): MxNewMx3dShapeObject;
 }
-export declare class MxNewMx3dGeCircle extends MxNewMx3dGeConic {
-	constructor(theCSYSR: MxNewMx3dGeCSYSR, theRadius: number);
-	TransformedParameter(U: number, T: MxNewMx3dGeTrsf): number;
-	ParametricTransformation(T: MxNewMx3dGeTrsf): number;
-	Reversed(): MxNewMx3dGeCircle;
-	Period(): number;
-	Value(U: number): MxNewMx3dGePoint;
+export declare class MxNewMx3dGeCircle extends MxNewMx3dGeObject {
+	constructor();
+	constructor(theA2: MxNewMx3dGeCSYSR, theRadius: number);
 	SetAxis(theA1: MxNewMx3dGeAxis): void;
 	SetLocation(theP: MxNewMx3dGePoint): void;
 	SetPosition(theA2: MxNewMx3dGeCSYSR): void;
+	SetRadius(theRadius: number): void;
+	Area(): number;
 	Axis(): MxNewMx3dGeAxis;
+	Length(): number;
 	Location(): MxNewMx3dGePoint;
 	Position(): MxNewMx3dGeCSYSR;
+	Radius(): number;
 	XAxis(): MxNewMx3dGeAxis;
 	YAxis(): MxNewMx3dGeAxis;
-	Reverse(): void;
-	Continuity(): MdGe.MxGAShapeEnum;
-	IsCN(N: number): boolean;
-	SetRadius(R: number): void;
-	Radius(): number;
-	ReversedParameter(U: number): number;
-	Eccentricity(): number;
-	FirstParameter(): number;
-	LastParameter(): number;
-	IsClosed(): boolean;
-	IsPeriodic(): boolean;
-	D0(U: number, P: MxNewMx3dGePoint): void;
-	D1(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec): void;
-	D2(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec, V2: MxNewMx3dGeVec): void;
-	D3(U: number, P: MxNewMx3dGePoint, V1: MxNewMx3dGeVec, V2: MxNewMx3dGeVec, V3: MxNewMx3dGeVec): void;
-	DN(U: number, N: number): MxNewMx3dGeVec;
-	Transform(T: MxNewMx3dGeTrsf): void;
-	Edge(p1: number, p2: number): MxNewMx3dShapeEdge;
-	Wire(): MxNewMx3dShapeWire;
+	Distance(theP: MxNewMx3dGePoint): number;
+	SquareDistance(theP: MxNewMx3dGePoint): number;
+	Contains(theP: MxNewMx3dGePoint, theLinearTolerance: number): boolean;
+	MirrorByPoint(theP: MxNewMx3dGePoint): void;
+	MirroredByPoint(theP: MxNewMx3dGePoint): MxNewMx3dGeCircle;
+	MirrorByAxis(theA1: MxNewMx3dGeAxis): void;
+	MirroredByAxis(theA1: MxNewMx3dGeAxis): MxNewMx3dGeCircle;
+	MirrorByCSYSR(theA2: MxNewMx3dGeCSYSR): void;
+	MirroredByCSYSR(theA2: MxNewMx3dGeCSYSR): MxNewMx3dGeCircle;
+	Rotate(theA1: MxNewMx3dGeAxis, theAng: number): void;
+	Rotated(theA1: MxNewMx3dGeAxis, theAng: number): MxNewMx3dGeCircle;
+	Scale(theP: MxNewMx3dGePoint, theS: number): void;
+	Scaled(theP: MxNewMx3dGePoint, theS: number): MxNewMx3dGeCircle;
+	Transform(theT: MxNewMx3dGeTrsf): void;
+	Transformed(theT: MxNewMx3dGeTrsf): MxNewMx3dGeCircle;
+	TranslateByVec(theV: MxNewMx3dGeVec): void;
+	TranslatedByVec(theV: MxNewMx3dGeVec): MxNewMx3dGeCircle;
+	TranslateBy2Points(theP1: MxNewMx3dGePoint, theP2: MxNewMx3dGePoint): void;
+	TranslatedBy2Points(theP1: MxNewMx3dGePoint, theP2: MxNewMx3dGePoint): MxNewMx3dGeCircle;
 }
 export declare class MxNewMx3dShapeObject extends MxNewMx3dBaseObject {
 	constructor(p?: object);
@@ -11165,6 +12051,7 @@ export declare class MxNewMx3dView extends MxNewMx3dBaseObject {
 	setCustomClipPlaneReverse(): void;
 	setCustomClipPlaneDirection(x: number, y: number, z: number): void;
 	displaySymbolText(theSymbol: MxNewMx3dSymbolText): void;
+	displayDimension(theDimension: MxNewMx3dDimObject): void;
 	addModelTexture(theFileName: string): void;
 	removeModelTexture(): void;
 	setGradientBgColor(theColor1: MxNewMx3dGeColor, theColor2: MxNewMx3dGeColor, theMethod: MdGe.MxGradientFillMethod): void;
@@ -12424,6 +13311,189 @@ export declare class MxNewMx3dGeMaterial extends MxNewMx3dBaseObject {
 	IsDifferent(theOther: MxNewMx3dGeMaterial): boolean;
 	IsEqual(theOther: MxNewMx3dGeMaterial): boolean;
 }
+export declare class MxNewMx3dAspectLine extends MxNewMx3dAspectObject {
+	constructor(theColor: MxNewMx3dGeColor, theType: MdGe.MxTypeOfLine, theWidth: number);
+	SetColor(theColor: MxNewMx3dGeColor): void;
+	SetTypeOfLine(theType: MdGe.MxTypeOfLine): void;
+	SetWidth(theWidth: number): void;
+}
+export declare class MxNewMx3dAspectText extends MxNewMx3dAspectObject {
+	constructor(p?: object);
+	SetColor(theColor: MxNewMx3dGeColor): void;
+	SetFont(theFont: string): void;
+	SetHeight(theHeight: number): void;
+	SetAngle(theAngle: number): void;
+	Height(): number;
+	Angle(): number;
+	SetHorizontalJustification(theJustification: MdGe.MxHorizontalTextAlignment): void;
+	SetVerticalJustification(theJustification: MdGe.MxVerticalTextAlignment): void;
+	SetOrientation(theOrientation: MdGe.MxTextPath): void;
+	HorizontalJustification(): MdGe.MxHorizontalTextAlignment;
+	VerticalJustification(): MdGe.MxVerticalTextAlignment;
+	Orientation(): MdGe.MxTextPath;
+}
+export declare class MxNewMx3dAspectArrow extends MxNewMx3dAspectObject {
+	constructor();
+	constructor(anAngle: number, aLength: number);
+	SetAngle(anAngle: number): void;
+	Angle(): number;
+	SetLength(theLength: number): void;
+	Length(): number;
+	SetZoomable(theIsZoomable: boolean): void;
+	IsZoomable(): boolean;
+	SetColor(theColor: MxNewMx3dGeColor): void;
+}
+export declare class MxNewMx3dAspectDim extends MxNewMx3dAspectObject {
+	constructor(p?: object);
+	SetLineAspect(theAspect: MxNewMx3dAspectLine): void;
+	SetTextAspect(theAspect: MxNewMx3dAspectText): void;
+	IsText3d(): boolean;
+	MakeText3d(isText3d: boolean): void;
+	IsTextShaded(): boolean;
+	MakeTextShaded(theIsTextShaded: boolean): void;
+	IsArrows3d(): boolean;
+	MakeArrows3d(theIsArrows3d: boolean): void;
+	IsUnitsDisplayed(): boolean;
+	MakeUnitsDisplayed(theIsDisplayed: boolean): void;
+	SetArrowOrientation(theArrowOrient: MdGe.MxDimensionArrowOrientation): void;
+	ArrowOrientation(): MdGe.MxDimensionArrowOrientation;
+	SetTextVerticalPosition(thePosition: MdGe.MxDimensionTextVerticalPosition): void;
+	TextVerticalPosition(): MdGe.MxDimensionTextVerticalPosition;
+	SetTextHorizontalPosition(thePosition: MdGe.MxDimensionTextHorizontalPosition): void;
+	TextHorizontalPosition(): MdGe.MxDimensionTextHorizontalPosition;
+	SetArrowAspect(theAspect: MxNewMx3dAspectArrow): void;
+	SetCommonColor(theColor: MxNewMx3dGeColor): void;
+	SetExtensionSize(theSize: number): void;
+	ExtensionSize(): number;
+	SetArrowTailSize(theSize: number): void;
+	ArrowTailSize(): number;
+	SetValueStringFormat(theFormat: string): void;
+	ValueStringFormat(): string;
+}
+export declare class MxNewMx3dDimDiameter extends MxNewMx3dDimObject {
+	constructor(theCircle: MxNewMx3dGeCircle);
+	constructor(theCircle: MxNewMx3dGeCircle, thePlane: MxNewMx3dGePlane);
+	Circle(): MxNewMx3dGeCircle;
+	AnchorPoint(): MxNewMx3dGePoint;
+	Shape(): MxNewMx3dShapeObject;
+	SetMeasuredGeometry(theCircle: MxNewMx3dGeCircle): void;
+	SetTextPosition(theTextPos: MxNewMx3dGePoint): void;
+	GetTextPosition(): MxNewMx3dGePoint;
+	SetDisplayUnits(theUnits: string): void;
+	SetModelUnits(theUnits: string): void;
+	GetValue(): number;
+	SetComputedValue(): void;
+	SetCustomValue(theValue: number): void;
+	GetPlane(): MxNewMx3dGePlane;
+	GetGeometryType(): number;
+	SetCustomPlane(thePlane: MxNewMx3dGePlane): void;
+	UnsetCustomPlane(): void;
+	IsTextPositionCustom(): boolean;
+	SetDimensionAspect(theDimensionAspect: MxNewMx3dAspectDim): void;
+	KindOfDimension(): MdGe.MxKindOfDimension;
+	UnsetFixedTextPosition(): void;
+	SelToleranceForText2d(): number;
+	SetSelToleranceForText2d(theTol: number): void;
+	GetFlyout(): number;
+	SetFlyout(theFlyout: number): void;
+	IsValid(): boolean;
+}
+export declare class MxNewMx3dDimRadius extends MxNewMx3dDimObject {
+	constructor(theCircle: MxNewMx3dGeCircle);
+	constructor(theCircle: MxNewMx3dGeCircle, theAnchorPoint: MxNewMx3dGePoint);
+	Circle(): MxNewMx3dGeCircle;
+	AnchorPoint(): MxNewMx3dGePoint;
+	Shape(): MxNewMx3dShapeObject;
+	SetMeasuredGeometry(theCircle: MxNewMx3dGeCircle): void;
+	SetMeasuredGeometry(theCircle: MxNewMx3dGeCircle, theAnchorPoint: MxNewMx3dGePoint, theHasAnchor: boolean): void;
+	SetTextPosition(theTextPos: MxNewMx3dGePoint): void;
+	GetTextPosition(): MxNewMx3dGePoint;
+	GetValue(): number;
+	SetComputedValue(): void;
+	SetCustomValue(theValue: number): void;
+	GetPlane(): MxNewMx3dGePlane;
+	GetGeometryType(): number;
+	SetCustomPlane(thePlane: MxNewMx3dGePlane): void;
+	UnsetCustomPlane(): void;
+	IsTextPositionCustom(): boolean;
+	SetDimensionAspect(theDimensionAspect: MxNewMx3dAspectDim): void;
+	KindOfDimension(): MdGe.MxKindOfDimension;
+	UnsetFixedTextPosition(): void;
+	SelToleranceForText2d(): number;
+	SetSelToleranceForText2d(theTol: number): void;
+	GetFlyout(): number;
+	SetFlyout(theFlyout: number): void;
+	IsValid(): boolean;
+}
+export declare class MxNewMx3dDimAngle extends MxNewMx3dDimObject {
+	constructor(theFirstEdge: MxNewMx3dShapeEdge, theSecondEdge: MxNewMx3dShapeEdge);
+	constructor(theFirstPoint: MxNewMx3dGePoint, theSecondPoint: MxNewMx3dGePoint, theThirdPoint: MxNewMx3dGePoint);
+	FirstPoint(): MxNewMx3dGePoint;
+	SecondPoint(): MxNewMx3dGePoint;
+	CenterPoint(): MxNewMx3dGePoint;
+	FirstShape(): MxNewMx3dShapeObject;
+	SecondShape(): MxNewMx3dShapeObject;
+	ThirdShape(): MxNewMx3dShapeObject;
+	SetMeasuredGeometry(theCone: MxNewMx3dShapeFace): void;
+	SetMeasuredGeometry(theFirstEdge: MxNewMx3dShapeEdge, theSecondEdge: MxNewMx3dShapeEdge): void;
+	SetMeasuredGeometry(theFirstPoint: MxNewMx3dGePoint, theSecondPoint: MxNewMx3dGePoint, theThridPoint: MxNewMx3dGePoint): void;
+	SetTextPosition(theTextPos: MxNewMx3dGePoint): void;
+	GetTextPosition(): MxNewMx3dGePoint;
+	GetDisplayUnits(): string;
+	GetModelUnits(): string;
+	SetDisplayUnits(theUnits: string): void;
+	SetModelUnits(theUnits: string): void;
+	SetType(theType: MdGe.MxTypeOfAngle): void;
+	GetType(): MdGe.MxTypeOfAngle;
+	SetArrowsVisibility(theType: MdGe.MxTypeOfAngleArrowVisibility): void;
+	GetArrowsVisibility(): MdGe.MxTypeOfAngleArrowVisibility;
+	GetValue(): number;
+	SetComputedValue(): void;
+	SetCustomValue(theValue: number): void;
+	GetPlane(): MxNewMx3dGePlane;
+	GetGeometryType(): number;
+	SetCustomPlane(thePlane: MxNewMx3dGePlane): void;
+	UnsetCustomPlane(): void;
+	IsTextPositionCustom(): boolean;
+	SetDimensionAspect(theDimensionAspect: MxNewMx3dAspectDim): void;
+	KindOfDimension(): MdGe.MxKindOfDimension;
+	UnsetFixedTextPosition(): void;
+	SelToleranceForText2d(): number;
+	SetSelToleranceForText2d(theTol: number): void;
+	GetFlyout(): number;
+	SetFlyout(theFlyout: number): void;
+	IsValid(): boolean;
+}
+export declare class MxNewMx3dDimLength extends MxNewMx3dDimObject {
+	constructor();
+	constructor(theEdge: MxNewMx3dShapeEdge, thePlane: MxNewMx3dGePlane);
+	constructor(theFirstPoint: MxNewMx3dGePoint, theSecondPoint: MxNewMx3dGePoint, thePlane: MxNewMx3dGePlane);
+	FirstPoint(): MxNewMx3dGePoint;
+	SecondPoint(): MxNewMx3dGePoint;
+	FirstShape(): MxNewMx3dShapeObject;
+	SecondShape(): MxNewMx3dShapeObject;
+	SetMeasuredGeometry(theFirstPoint: MxNewMx3dGePoint, theSecondPoint: MxNewMx3dGePoint, thePlane: MxNewMx3dGePlane): void;
+	SetMeasuredShapes(theFirstShape: MxNewMx3dShapeObject, theSecondShape: MxNewMx3dShapeObject): void;
+	SetTextPosition(theTextPos: MxNewMx3dGePoint): void;
+	GetTextPosition(): MxNewMx3dGePoint;
+	SetDirection(theDirection: MxNewMx3dGeDir, theUseDirection: boolean): void;
+	GetValue(): number;
+	SetComputedValue(): void;
+	SetCustomValue(theValue: number): void;
+	GetPlane(): MxNewMx3dGePlane;
+	GetGeometryType(): number;
+	SetCustomPlane(thePlane: MxNewMx3dGePlane): void;
+	UnsetCustomPlane(): void;
+	IsTextPositionCustom(): boolean;
+	SetDimensionAspect(theDimensionAspect: MxNewMx3dAspectDim): void;
+	KindOfDimension(): MdGe.MxKindOfDimension;
+	UnsetFixedTextPosition(): void;
+	SelToleranceForText2d(): number;
+	SetSelToleranceForText2d(theTol: number): void;
+	GetFlyout(): number;
+	SetFlyout(theFlyout: number): void;
+	IsValid(): boolean;
+}
 export type Map = any;
 /**
  * cad地图对象