// Generated by dts-bundle-generator v6.13.0

import { AcquirePointOsnapMode, AcquirePointType, DetailedResult, DynamicInputType, McEdGetPointWorldDrawObject, MrxDbgUiPrBaseReturn, MrxDbgUiPrPoint, MxCursorType, MxDbEntity, MxDrawObject, OsModeExParam } from 'mxdraw';

/**
 * McRxObject 是 MxCAD 中所有 Rx 对象的基础基类，负责承接底层 C++/原生对象与 TypeScript 侧的桥接。
 *
 * @description
 * 该类用于封装底层对象的通用能力，并为各类 CAD 对象提供统一的访问入口。
 * 通过它可以完成：
 * - 获取底层实现对象（imp）；
 * - 读取/设置对象的 JSON 数据；
 * - 判断对象是否为空或属于某个类型；
 * - 作为其他实体对象的父类，为派生类统一管理生命周期和对象引用。
 *
 * 使用方式：
 * 1. 通过具体子类继承此类，持有底层原生对象实例；
 * 2. 调用 getImp()、getJson()、setJson()、isKindOf() 等方法访问公共能力；
 * 3. 在需要时配合子类对象继续进行更细粒度的 CAD 数据操作。
 *
 * 总结：在实际开发中，McRxObject 通常不直接用于业务绘制，而是作为底层对象的统一抽象层，供各类 CAD 对象继承和扩展，简化对象生命周期管理和通用能力访问。
 *
 */
export declare class McRxObject {
	/**
	 * 内部实现对象。
	 */
	imp: any;
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 受保护的构造函数，用于特定子类的初始化
	 * @param imp 内部实现对象
	 */
	protected constructor_MxCADResbuf(imp: any): void;
	/**
	 * 获取内部实现对象。
	 * @returns 内部实现对象。
	 */
	getImp(): any;
	/**
	 * 初始化临时对象。
	 * @param imp 内部实现对象。
	 */
	initTempObject(imp: any): void;
	/**
	 * 获取对象名称。
	 * @returns 返回对象名
	 */
	get objectName(): string;
	/**
	 * 得到对象的DXF组码的类型名，这个和AutoCAD中的DXF组码是一样。
	 * 比如直线的类型名为：McDbLine，DXF0组码值: LINE,DXF0组码值可以用来构造集时的类型过滤。
	 */
	get dxf0(): string;
	/**
	 * 获取 JSON 格式的字符串。
	 * @returns JSON 格式的字符串。
	 */
	getJson(): string;
	/**
	 * 设置 JSON 格式的字符串。
	 * @param str JSON 格式的字符串。
	 * @returns 是否设置成功。
	 */
	setJson(str: string): boolean;
	/** 判断对象类型
	 * @param sObjectName 类型名
	 * @returns 返回对象是否是目标类型
	 */
	isKindOf(sObjectName: string): boolean;
	/**
	 * 判断是否为空对象
	 * */
	isNull(): any;
}
/**
 * 枚举类型 McObjectIdType 表示对象的类型。
 *
 * @remarks
 * - kMxCAD：  CAD 对象。
 * - kMxDraw： 绘图对象。
 * - kInvalid：无效对象。
 */
export declare enum McObjectIdType {
	/** CAD 对象 */
	kMxCAD = 0,
	/** 绘图对象 */
	kMxDraw = 1,
	/** 无效对象 */
	kInvalid = 2
}
/**
 * McObjectId 是 MxCAD 中对象实例的标识符，负责描述某个 CAD 对象在数据库中的引用。
 *
 * @description
 * 该类用于表示一个对象的 ID，并携带对象类型信息，便于在底层数据库和 TypeScript 侧之间建立桥接。
 * 通过它可以完成：
 * - 判断对象 ID 是否有效或为空；
 * - 删除对象、查询对象状态；
 * - 把对象 ID 转换成对应的 McDbObject / McDbEntity / McDbCurve 等对象；
 * - 通过类型判断确认对象是否属于某个 CAD 类。
 *
 * 使用方式：
 * 1. 通过对象操作结果或绘制命令获取 McObjectId；
 * 2. 调用 isValid()、isNull()、isKindOf() 进行判定；
 * 3. 结合 getMcDbObject()、getMcDbEntity() 等方法获取真实对象实例并继续编辑。
 *
 * 总结：在实际开发中，McObjectId 是 CAD 对象访问的入口，通常用来拿到数据库中的对象引用，然后继续执行选择、查询、删除、转换等操作。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbLine, McGePoint3d } from "mxcad";
 *
 * async function testObjectId() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const line = new McDbLine(new McGePoint3d(0, 0, 0), new McGePoint3d(100, 0, 0));
 *   const id = mxcad.drawEntity(line);
 *
 *   if (!id || id.isNull()) {
 *     console.log("对象创建失败");
 *     return;
 *   }
 *
 *   console.log("对象是否有效:", id.isValid());
 *   console.log("对象是否为空:", id.isNull());
 *   console.log("对象是否为直线:", id.isKindOf("McDbLine"));
 *
 *   const ent = id.getMcDbEntity();
 *   if (ent) {
 *     console.log("实体类型:", ent.objectName);
 *   }
 * }
 * ```
 */
export declare class McObjectId {
	/** 对象ID */
	id: number;
	/** 对象类型 */
	type: McObjectIdType;
	/**
	 * 创建一个McObjectId实例。
	 * @param id 对象的唯一标识符。
	 * @param type 对象的类型。
	 */
	constructor(id?: number, type?: McObjectIdType);
	/**
	 * @internal
	 * @param id
	 */
	initFromCpp(id: number | string): void;
	/**
	* @internal
	* @param id
	*/
	getValueFromCpp(): any;
	/**
	 * id是否有效.
	 * @returns 布尔值
	 */
	isValid(): boolean;
	/**
	  * id是否为NULL.
	  * @return 布尔值
	 */
	isNull(): boolean;
	/**
	 * id是指向的对像，是否是删除状态.
	 * @return 布尔值
	 */
	isErase(): boolean;
	/**
	 * 删除对象。
	 * @param isErase 是否删除
	 */
	erase(isErase?: boolean): void;
	/**
	 * 返回MxCAD McDbObject对象。
	 * @returns 返回一个数据库对象
	 */
	getMcDbObject(): McDbObject | null;
	/**
	* 判断一个对象的类型
	* @param className 类型名
	*/
	isKindOf(className: string): boolean;
	/**
	 * 返回MxCAD McDbEntity 对象。
	 */
	getMcDbEntity(): McDbEntity | null;
	/**
	 * 返回MxCAD McDbCurve 对象。
	 */
	getMcDbCurve(): McDbCurve | null;
	/**
	 * 返回 MxCAD 块表记录对象。
	 */
	getMcDbBlockTableRecord(): McDbBlockTableRecord | null;
	/**
	 * 返回 MxCAD 图层表记录对象。
	 */
	getMcDbLayerTableRecord(): McDbLayerTableRecord | null;
	/**
	* 返回 MxCAD 标注样表记录对象。
	*/
	getMcDbDimStyleTableRecord(): McDbDimStyleTableRecord | null;
	/**
	 * 返回 MxCAD 线型表记录对象。
	 */
	getMcDbLinetypeTableRecord(): McDbLinetypeTableRecord | null;
	/**
	 * 返回 MxCAD 文字样式表记录对象。
	 */
	getMcDbTextStyleTableRecord(): McDbTextStyleTableRecord | null;
	/**
	 * 返回MxCAD McDbDimension 对象。
	 */
	getMcDbDimension(): McDbDimension | null;
	/**
	 * 获取自定义实体
	 */
	getMcDbCustomEntity(): McDbCustomEntity | null;
	/**
	 * 克隆对象
	 * @returns 返回克隆后的数据库对象
	 */
	clone(): McDbObject | null;
	/**
	 * 返回id指向的对象名称.
	 */
	getObjectName(): string;
	/**
	 * 返回MxDraw对象。
	 */
	getMxDbEntity(): MxDbEntity | null;
	/**
	 * 获取栅格图像信息
	 */
	getMcDbRasterImageDef(): McDbRasterImageDef | null;
	/**
	 * 获取数据库中的字典信息
	 */
	getMcDbDictionary(): McDbDictionary | null;
	/**
	 * 获取扩展记录信息
	 */
	getMcDbXrecord(): McDbXrecord | null;
	/**
	 * 返回MxCAD McDbGroup 对象。
	 */
	getMcDbGroup(): McDbGroup | null;
}
/**
 * McDbObject 是数据库对象的基础类，负责承载 CAD 数据库中各类对象的通用能力。
 *
 * @description
 * 该类用于表示图数据库中的一个对象实体，并提供通用的对象操作接口。
 * 通过它可以完成：
 * - 获取对象 ID、句柄、数据库、拥有者以及扩展字典；
 * - 删除、反删除、克隆对象；
 * - 判断对象是否已删除；
 * - 触发对象修改事件，更新图形显示；
 * - 作为所有数据库实体对象的公共基类，为派生类提供统一行为。
 *
 * 使用方式：
 * 1. 先从对象 ID 或数据库中获取某个 McDbObject；
 * 2. 调用 getObjectID()、getDatabase()、getHandle() 等方法读取对象元信息；
 * 3. 使用 erase()、clone()、assertObjectModification() 等方法进行对象操作；
 * 4. 进一步根据对象类型转换到具体实体对象继续编辑。
 *
 * 总结：在实际开发中，McDbObject 主要用于统一管理数据库对象的通用属性和基础操作，是所有 CAD 实体对象的基础抽象层。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbLine, McGePoint3d } from "mxcad";
 *
 * async function testDbObject() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const line = new McDbLine(new McGePoint3d(0, 0, 0), new McGePoint3d(200, 0, 0));
 *   const id = mxcad.drawEntity(line);
 *   if (!id || id.isNull()) return;
 *
 *   const obj = id.getMcDbObject();
 *   if (!obj) return;
 *
 *   const objectId = obj.getObjectID();
 *   console.log("对象 ID:", objectId);
 *   console.log("对象句柄:", obj.getHandle());
 *   console.log("对象所在数据库:", obj.getDatabase());
 *
 *   const isErased = obj.isErased();
 *   console.log("是否已删除:", isErased);
 * }
 * ```
 */
export declare class McDbObject extends McRxObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取对象 ID。
	 * @returns 对象 ID。
	 */
	getObjectID(): McObjectId;
	/**
	 * 删除对象。
	 * @returns 是否删除成功。
	 */
	erase(): boolean;
	/**
	 * 对象是否已经删除
	 */
	isErased(): boolean;
	/**
	 * 反删除对象。
	 */
	unErase(): boolean;
	/**
	 * 克隆对象。
	 * @returns 克隆出的对象。
	 */
	clone(): McDbObject | null;
	/**
	* 得到对象句柄
	* @return 返回对象句柄
	*/
	getHandle(): string;
	/**
	* 得到对象所在的数据库
	* @return 返回数据库
	*/
	getDatabase(): McDbDatabase;
	/**
	 * 得到对象拥用者的id
	 */
	getOwnerID(): number;
	/**
	 * 得到对象的扩展字典数据.
	 * @return 扩展字典数据
	 */
	getExtensionDictionary(): McDbDictionary;
	/**
	 * 是否有扩展字典数据.
	 */
	isHaveExtensionDictionary(): boolean;
	/**
	 * 创建对象的扩展字典数据.
	 */
	createExtensionDictionary(): boolean;
	/**
	 * 获取对象的索引ID
	 */
	getDatabaseIndexId(): number;
	/** 移动对象的夹点
	 * @param iIndex 索引
	 * @param dXOffset X轴偏移量
	 * @param dYOffset Y轴偏移量
	 * @param dZOffset Z轴偏移量
	 */
	moveGripPointsAt(iIndex: number, dXOffset: number, dYOffset: number, dZOffset: number): any;
	/**
	 * 获取对象的夹点数组
	 */
	getGripPoints(): McGePoint3dArray;
	/**
	* 获取对象的夹点对应的编辑基点索引。
	*/
	getGripEditBasePointsIndex(): number[];
	/**
	* @internal
	* MxCAD辅助,内部使用
	* ```
	*/
	tempRelationObject(): number;
	/**
	 * @internal
	 * MxCAD辅助,内部使用
	 * ```
	 */
	freeTempRelationObject(): void;
	/**
	  * 设置对象被改变的状态，可自动触发更新显示函数，更新显示。
	  * 比如块表记录更新了，需要通知块引用更新显示，可以调用该函数。
	  * @param autoUndo 这次修改是否要自动支持撤销,默认为false
	  */
	assertObjectModification(autoUndo?: boolean): number;
}
/**
 * McDbObjectArray 是多个 McDbObject 对象的集合容器，用于批量存储、遍历和管理数据库对象。
 *
 * @description
 * 该类适用于一组对象的统一处理场景，比如批量遍历、筛选、统计和后续编辑。
 * 通过它可以完成：
 * - 批量保存一组数据库对象；
 * - 按索引访问对象；
 * - 遍历数组并执行统一逻辑；
 * - 判断集合是否为空。
 *
 * 使用方式：
 * 1. 通过数据库查询或对象集合返回创建 McDbObjectArray；
 * 2. 调用 forEach() 遍历每个对象；
 * 3. 使用 length()、empty() 进行集合状态判断；
 * 4. 根据需要把对象继续转换为具体实体类型做后续处理。
 *
 * 总结：在实际开发中，McDbObjectArray 主要用于批量对象处理，适合需要统一遍历、筛选或统计一组数据库对象的场景。
 *
 * @example
	 * ```ts
	 * import { MxCADUiPrPoint, MxCpp, MxCADUiPrEntity, McDbObject } from 'mxcad'
	   async function test(){
			let getFristPoint = new MxCADUiPrPoint();
			let offsetDist = 10 ;
			let getent = new MxCADUiPrEntity();
			getent.setMessage('指定偏移对象');
			let ent_id = await getEnt.go();
			if (!ent_id) return;
			let ent = (await ent_id.getMcDbEntity()) as McDbCurve;
			let getoOffPt = new MxCADUiPrPoint();
			getoOffPt.setMessage('指定偏移点');
			let offPt = await getoOffPt.go();
			if (!offPt) return;
			let objArr = ent.offsetCurves(offsetDist, offPt);
			if (objArr.length() === 0) return;
			objArr.forEach((obj: McDbObject) => {
				MxCpp.getCurrentCAD().drawEntity(obj as McDbEntity);
			});
	   }
	 * ```
 */
export declare class McDbObjectArray {
	/** 对象数组 */
	aryVal: McDbObject[];
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 遍历对象
	 */
	forEach(call: (val: McDbObject, index: number) => void): void;
	/**
	 * 数组长度
	 */
	length(): number;
	/**
	 * 清空数组
	 */
	empty(): boolean;
}
/**
 * McGePoint3d 表示三维空间中的一个点对象。
 *
 * @description
 * 该类用于描述和操作 CAD/三维场景中的坐标点，常见用途包括：
 * 计算两点距离、执行点与向量的运算、进行坐标变换以及与 Three.js 的向量对象互转。
 * 它是很多几何运算和图形绘制逻辑的基础类型。
 *
 * @example
 * ```ts
 * import { McGePoint3d, McGeVector3d, McGeMatrix3d } from "mxcad";
 *
 * const pt1 = new McGePoint3d(10, 20, 0);
 * const pt2 = new McGePoint3d(30, 40, 0);
 *
 * const distance = pt1.distanceTo(pt2);
 * console.log("距离：", distance);
 *
 * const vec = pt2.sub(pt1);
 * const matrix = new McGeMatrix3d();
 * matrix.setToTranslation(vec);//平移矩阵
 * pt1.transformBy(matrix);//应用平移矩阵
 * ```
 */
export declare class McGePoint3d {
	/**
	 * 坐标系的原点
	 * */
	static kOrigin: McGePoint3d;
	/** 内部实现对象 */
	imp: any;
	/**
	 * 构造函数。
	 * @param dX X 坐标。
	 * @param dY Y 坐标。
	 * @param dZ Z 坐标。
	 */
	constructor(dX?: number | object, dY?: number, dZ?: number);
	/**
	 * 将当前对象的坐标信息转换为 THREE.Vector3 类的实例
	 * @return THREE.Vector3实例对象
	*/
	toVector3(): THREE.Vector3;
	get vector3(): THREE.Vector3;
	set vector3(val: THREE.Vector3);
	/** 将three.js 的向量设置成点
	*/
	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, McGeVector3d } from "mxcad";
	*
	* const pt1 = new McGePoint3d(20,10,0);
	* 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, McGeVector3d } from "mxcad";
	 *
	 * const pt1 = new McGePoint3d(20,10,0);
	 * const pt = pt1.clone().subvec(new McGeVector3d(10,10,0));
	 * ```
	 */
	subvec(vec: McGeVector3d): this;
	/**
	 * 计算点减去向量后的新位置
	 * @param vec 向量
	 * @return 计算后的点对象
	 */
	sv(vec: McGeVector3d): this;
	/**
	 * 返回两点相减后得到的一个新的向量
	 * @param pt 三维点对象
	 * @return 三维点向量
	 * @example
	 * ```ts
	 * import { McGePoint3d } from "mxcad";
	 *
	 * const pt1 = new McGePoint3d(20,10,0);
	 * const pt2 = new McGePoint3d(50,20,0);
	 * const vec = pt1.sub(pt2);
	 * ```
	 */
	sub(pt: McGePoint3d): McGeVector3d;
	/**
	 * 计算两点距离
	 * @param pnt 三维点对象
	 * @return 两点距离
	 * @example
	 * ```ts
	 * import { McGePoint3d } from "mxcad";
	 *
	 * const pt1 = new McGePoint3d(20,10,0);
	 * const pt2 = new McGePoint3d(50,20,0);
	 * const dist = pt1.distanceTo(pt2);
	 * ```
	 */
	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 坐标。
	 * @param val X轴坐标值
	 */
	get x(): number;
	set x(val: number);
	/**
	 * 获取或设置 Y 坐标。
	 * @param val Y轴坐标值
	 */
	get y(): number;
	set y(val: number);
	/**
	 *获取或设置 Z 坐标。
	 * @param val Z轴坐标值
	 */
	get z(): number;
	set z(val: number);
}
/**
 * McGeVector3d 表示三维空间中的方向向量对象。
 *
 * @description
 * 该类用于描述和计算向量关系，常见场景包括：
 * 计算两个向量夹角、做点积和叉积、归一化、旋转，以及参与矩阵变换。
 * 它在 CAD 几何运算、方向判断和空间变换中非常常用。
 *
 * @example
 * ```ts
 * import { McGeVector3d } from "mxcad";
 *
 * const vec1 = new McGeVector3d(10, 0, 0);
 * const vec2 = new McGeVector3d(0, 10, 0);
 *
 * const angle = vec1.angleTo2(vec2, McGeVector3d.kZAxis);
 * const dot = vec1.dotProduct(vec2);
 * const cross = vec1.crossProduct(vec2);
 *
 * console.log("夹角：", angle);
 * console.log("点积：", dot);
 * console.log("叉积：", cross);
 * ```
 */
export declare class McGeVector3d {
	/**
   * 0长度向量
   * @example
   * ```ts
   * ```
   * */
	static kIdentity: McGeVector3d;
	/**
	 * X轴单位向量, 指向正 X 轴方向
	 * */
	static kXAxis: McGeVector3d;
	/**
	 * Y轴单位向量, 指向正 Y 轴方向
	 */
	static kYAxis: McGeVector3d;
	/**
	* Z轴单位向量, 指向正 Z 轴方向
	 */
	static kZAxis: McGeVector3d;
	/**
	 * Z轴单位向量, 指向负 Z 轴方向
	 */
	static kNegateZAxis: McGeVector3d;
	/** 内部实现对象 */
	imp: any;
	/**
	 * 构造函数。
	 * @param dX X 坐标。
	 * @param dY Y 坐标。
	 * @param dZ Z 坐标。
	 */
	constructor(dX?: number | object, dY?: number, dZ?: number);
	/** 转换为THREE.Vector3  */
	toVector3(): THREE.Vector3;
	setFromVector3(val: THREE.Vector3): this;
	get vector3(): THREE.Vector3;
	set vector3(val: 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 旋转角度。
	 * @param axis 旋转轴向量
	 * @example
	 * ```ts
	 * import { McGeVector3d } from "mxcad";
	 *
	 * const vec = new McGeVector3d(20,10,0);
	 * vec.rotateBy(Math.PI * 0.5);
	 * ```
	 *  */
	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";
	 *
	 * const vec1 = new McGeVector3d(20,10,0);
	 * const vec2 = new McGeVector3d(50,0,0);
	 * const angle = vec1.angleTo1(vec2);
	 * ```
	 * */
	angleTo1(vec: McGeVector3d): number;
	/** 计算两向量在[0, 2*Pi]范围内所夹的角度
	 * @example
	 * ```ts
	 * import { McGeVector3d } from "mxcad";
	 *
	 * const vec1 = new McGeVector3d(20,10,0);
	 * const angle = vec1.angleTo2(McGeVector3d.kXAxis, McGeVector3d.kNegateZAxis);
	 * ```
	 * */
	angleTo2(vec?: McGeVector3d, refVec?: McGeVector3d): number;
	/** 计算向量在[0, 2*Pi]范围内与X轴的夹角度
	* */
	angle(): number;
	/**
	 * 向量归一化操作
	 * @return 三维向量对象
	 * */
	normalize(): this;
	/**
	 * 获取向量长度
	 * @return 向量长度
	 * */
	length(): number;
	/**
	 * 检查当前向量是否为单位长度
	 * @return 布尔值
	 * */
	isUnitLength(): boolean;
	/**
	 * 是否为零向量
	 * @return 布尔值
	 * */
	isZeroLength(): boolean;
	/**
	 * 两向量的点积。
	 *
	 * 点积可以判断两个方向的相似程度：
	 * - 结果为 0：两个向量垂直；
	 * - 结果大于 0：两向量方向基本一致；
	 * - 结果小于 0：两向量方向相反。
	 *
	 * 它常用于判断向量是否垂直、判断投影方向、计算夹角余弦等几何场景。
	 *
	 * @param vec 三维向量对象
	 * @return 点积结果
	 * @example
	 * ```ts
	 * import { McGeVector3d } from "mxcad";
	 *
	 * // 方向向量：沿 X 轴正方向
	 * const v1 = new McGeVector3d(10, 0, 0);
	 *
	 * // 方向向量：沿 Y 轴正方向
	 * const v2 = new McGeVector3d(0, 10, 0);
	 *
	 * // 点积为 0，说明两个方向垂直
	 * const dot = v1.dotProduct(v2);
	 * console.log("dot:", dot); // 0
	 *
	 * // 继续判断一个向量是否和 X 轴同向
	 * const v3 = new McGeVector3d(5, 0, 0);
	 * const sameDir = v1.dotProduct(v3) > 0;
	 * console.log("同向：", sameDir); // true
	 * ```
	 * */
	dotProduct(vec: McGeVector3d): number;
	/**
	 * 两向量的交叉积
	 * @return 三维向量对象
	 * */
	crossProduct(vec: McGeVector3d): McGeVector3d;
	/**
	 * 判断比较两个向量是否相等
	 * @param vec 三维向量对象
	 * @return 布尔值
	 * */
	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;
	/**
   * 使用矩阵变换该向量
   * @param leftSide 变换矩阵
   * @returns 变换后的向量对象
   * @example
   */
	transformBy(leftSide: McGeMatrix3d): this;
	/**
	 * 获取或设置向量 X 坐标。
	 * @param val x轴坐标
	 */
	get x(): number;
	set x(val: number);
	/**
	 * 获取或设置向量 Y 坐标。
	 * @param val y轴坐标
	 */
	get y(): number;
	set y(val: number);
	/**
	 * 获取或设置向量 Z 坐标。
	 * @param val z轴坐标
	 */
	get z(): number;
	set z(val: number);
}
/**
 * McGeMatrix3d 表示三维空间中的变换矩阵对象。
 *
 * @description
 * 该类用于构造和应用平移、旋转、缩放、镜像等几何变换矩阵，
 * 可用于点、向量、实体对象的空间变换。它是实现 CAD 图形变换和坐标系转换的核心类型之一。
 *
 * @example
 * ```ts
 * import { McGeMatrix3d, McGePoint3d, McGeVector3d } from "mxcad";
 *
 * const matrix = new McGeMatrix3d();
 * matrix.setToTranslation(new McGeVector3d(20, 10, 0));//平移矩阵
 *
 * const pt = new McGePoint3d(1, 2, 0);
 * pt.transformBy(matrix);//应用平移矩阵
 *
 * console.log(pt.x, pt.y, pt.z);
 * ```
 */
export declare class McGeMatrix3d {
	/** 乘法的单位矩阵  */
	static kIdentity: McGeMatrix3d;
	/** 内部实现对象 */
	imp: any;
	/**
	 * 构造函数。
	 * @param imp 内部实现对象
	 */
	constructor(imp?: object);
	/**
	 * 复制对象的值
	 * @param val 三维矩阵对象
	 * @return 复制后的三维矩阵对象
	 */
	copy(val: McGeMatrix3d): this;
	/**
	 * 刻隆一个三维矩阵对象
	 * @return 三维矩阵对象
	 */
	clone(): McGeMatrix3d;
	/**
	 * 将矩阵设置为单位矩阵。
	 */
	setToIdentity(): this;
	/**
	 * 左乘指定的矩阵。
	 * @param leftSide 左侧矩阵。
	 * @return 返回左乘后的矩阵
	 */
	preMultBy(leftSide: McGeMatrix3d): this;
	/**
	 * 右乘指定的矩阵。
	 * @return 返回右乘后的矩阵
	 */
	postMultBy(rightSide: McGeMatrix3d): this;
	/**
	 * 将矩阵设置为两个矩阵的乘积。
	 * @param mat1 第一个矩阵。
	 * @param mat2 第二个矩阵。
	 */
	setToProduct(mat1: McGeMatrix3d, mat2: McGeMatrix3d): this;
	/**
	 * 求矩阵的逆矩阵。
	 */
	invert(): this;
	/**
	 * 判断矩阵是否为奇异矩阵。
	 * @returns 如果是奇异矩阵返回 true，否则返回 false。
	 */
	isSingular(): boolean;
	/**
	 * 将矩阵转置。
	 */
	transposeIt(): this;
	/**
	 * 判断矩阵是否与指定的矩阵相等。
	 * @param mat 指定的矩阵。
	 * @returns 如果相等返回 true，否则返回 false。
	 */
	isEqualTo(mat: McGeMatrix3d): boolean;
	/**
	 * 求矩阵的行列式。
	 * @returns 矩阵的行列式。
	 */
	det(): number;
	/**
	 * 将矩阵设置为指定的坐标系。
	 * @param origin 坐标系原点。
	 * @param xAxis X 轴向量。
	 * @param yAxis Y 轴向量。
	 * @param zAxis Z 轴向量。
	 */
	setCoordSystem(origin: McGePoint3d, xAxis: McGeVector3d, yAxis: McGeVector3d, zAxis: McGeVector3d): this;
	/**
	 * 将矩阵设置为平移矩阵。
	 * @param vec 平移向量。
	 * @example
	 * ```ts
	 *import { McGeMatrix3d, McDbEntity } from "mxcad";
  
	  let matrix = new McGeMatrix3d();
	  const event = new McDbEntity();
	  matrix.setToTranslation(new McGeVector3d(20,10,0));
	  event.transformBy(matrix);
	 * ```
	 */
	setToTranslation(vec: McGeVector3d): this;
	/**
	 * 将矩阵设置为绕指定轴旋转指定角度的矩阵。
	 * @param angle 旋转角度。
	 * @param axis 旋转轴向量。
	 * @param center 旋转中心点。
	 * @example
	 * ```ts
	 *import { McGeMatrix3d, McDbEntity } from "mxcad";
  
	  let matrix = new McGeMatrix3d();
	  const event = new McDbEntity();
	  matrix.setToRotation(Math.PI, McGeVector3d.kZAxis / 180.0, new McGeVector3d(20,10,0));
	  event.transformBy(matrix);
	 * ```
	 */
	setToRotation(angle: number, axis: McGeVector3d, center: McGePoint3d): this;
	/**
	 * 将矩阵设置为缩放矩阵。
	 * @param scaleAll 缩放因子。
	 * @param center 缩放中心点。
	 * @example
	 * ```ts
	 *import { McGeMatrix3d, McDbEntity } from "mxcad";
  
	  let matrix = new McGeMatrix3d();
	  const event = new McDbEntity();
	  matrix.setToScaling(0.5, new McGeVector3d(0, 0, 0));
	  event.transformBy(matrix);
	 * ```
	 */
	setToScaling(scaleAll: number, center: McGePoint3d): this;
	/**
	 * 将矩阵设置为镜向矩阵
	 * @param pt1 镜向平面上的第一个点。
	 * @param pt2 镜向平面上的第二个点。
	 * @example
	 * ```ts
	 *import { McGeMatrix3d, McDbEntity } from "mxcad";
  
	  const matrix = new McGeMatrix3d();
	  const event = new McDbEntity();
	  matrix.setMirror(new McGeVector3d(0, 0, 0), new McGeVector3d(20, 0, 0));
	  event.transformBy(matrix);
	* ```
	*/
	setMirror(pt1: McGePoint3d, pt2: McGePoint3d): this;
	/**
	 * 获取矩阵的缩放因子。
	 * @returns 矩阵的缩放因子。
	 * @example
	 * ```ts
	 * // matrix 表示一个三维矩阵对象
	 * const scaleNum = matrix.scale()
	 * console.log(scaleNum)
	 * ```
	 */
	scale(): number;
	/**
	 * 获取矩阵在XY平面的旋转角度因子。
	 * @returns旋转角度因子。
	 * @example
	 */
	angleXYPlane(): number;
	/**
	 * 获取矩阵中指定位置的元素值。
	 * @param row 行索引。
	 * @param col 列索引。
	 * @returns 指定位置的元素值。
	 */
	getData(row: number, col: number): number;
	/**
	 * 设置矩阵中指定位置的元素值。
	 * @param row 行索引。
	 * @param col 列索引。
	 * @param val 指定位置的元素值。
	 */
	setData(row: number, col: number, val: number): void;
	/**
	 * 返回矩阵的所有定义数据。
	 */
	getDatas(): string;
	setDatas(str: string): boolean;
	/**
	* 矩阵定义数据
	*/
	get matrix4(): THREE.Matrix4;
	set matrix4(mat: THREE.Matrix4);
	/**
   * 返回THREE.Matrix4
   */
	toMatrix4(): THREE.Matrix4;
}
/**
 * McGeLongArray 表示一组整数值的数组容器。
 *
 * @description
 * 该类用于存储和操作一组整数数据，常用于 CAD 内部的数值缓存、
 * 对象 ID 集合、颜色通道数据等场景。它提供了追加、读取、修改和遍历等常用能力。
 *
 * @example
 * ```ts
 * import { McGeLongArray } from "mxcad";
 *
 * const values = new McGeLongArray();
 * values.append(10);
 * values.append(20);
 * values.append(30);
 *
 * console.log(values.length())//获取数组长度;
 * console.log(values.at(1))//获取索引为1的元素值;
 * ```
 */
export declare class McGeLongArray {
	/** 内部实现对象 */
	imp: any;
	/**
	 * 构造函数。
	 * @param imp 内部实现对象
	 */
	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 数组
	 */
	copyFormAryId(aryId: McObjectId[]): this;
	/**
	* 向数组中添加一个值
	* @param val 整数值
	*/
	append(val: number): void;
	/**
	 * 返回数组长度
	 * @return 数组长度
	 */
	length(): number;
	/**
	 * 根据数组索引得到数据元素的值
	 * @param index 数组索引
	 * @return 返回元素值
	 */
	at(index: number): number;
	/**
	 * 通过数组索引设置数据元素的值
	 * @param index 数组索引值
	 * @param val 整数数值
	 */
	setAt(index: number, val: number): void;
	/**
	 * 清空数组
	 */
	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;
}
/**
 * McGeStringArray 表示一组字符串值的数组容器。
 *
 * @description
 * 该类用于存储和处理字符串集合，常用于图层名、线型名、文本样式名、
 * 布局名等 CAD 字符串信息的批量管理。它支持追加、读取、修改、遍历和清空。
 *
 * @example
 * ```ts
 * import { McGeStringArray } from "mxcad";
 *
 * const names = new McGeStringArray();
 * names.append("Layer1");
 * names.append("Layer2");
 *
 * console.log(names.at(0))//获取索引为0的元素值;
 * console.log(names.length())//获取数组长度;
 * ```
 */
export declare class McGeStringArray {
	/** 内部实现对象 */
	imp: any;
	/**
	 * 构造函数。
	 * @param imp 内部构造函数
	 */
	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 字符串
	*/
	append(val: string): void;
	/**
	 * 返回数组长度
	 * @return 数组长度
	 */
	length(): number;
	/**
	 * 根据数组索引得到数据元素的值
	 * @param index 数组索引
	 * @return 字符串
	 */
	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;
}
/**
 * McGePoint3dArray 表示一组三维点的数组容器。
 *
 * @description
 * 该类用于批量管理多个三维点，常用于构造折线、多段线、边界、路径点集及几何计算。
 * 通过它可以方便地追加点、读取点、设置点和遍历点集合。
 *
 * @example
 * ```ts
 * import { McGePoint3d, McGePoint3dArray } from "mxcad";
 *
 * const points = new McGePoint3dArray();
 * points.append(new McGePoint3d(0, 0, 0));
 * points.append(new McGePoint3d(10, 0, 0));
 * points.append(new McGePoint3d(10, 10, 0));
 *
 * const first = points.at(0);// 获取第一个点对象
 * console.log(first.x, first.y, first.z);
 * ```
 */
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, isDestroyImp?: boolean);
	/**
	 * 复制对象的值
	 * @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 三维点对象
	*/
	append(val: McGePoint3d): void;
	/**
	 * 返回数组长度
	 * @return 数组长度
	 */
	length(): number;
	/**
	 * 返回数组为空
	 * @return 布尔值
	 */
	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;
	/**
	 * 清空数组
	 * */
	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;
}
/**
 * McGeDoubleArray 表示一组双精度浮点数的数组容器。
 *
 * @description
 * 该类用于存储和处理浮点数集合，常见于数值采样、坐标值缓存、
 * 变换参数和其他需要连续浮点数数据的场景。
 *
 * @example
 * ```ts
 * import { McGeDoubleArray } from "mxcad";
 *
 * const values = new McGeDoubleArray();
 * values.append(1.2);
 * values.append(3.4);
 * values.append(5.6);
 *
 * console.log(values.at(1));//获取第一个索引位置的值;
 * console.log(values.length());//获取数组长度;
 * ```
 */
export declare class McGeDoubleArray {
	/** 内部实现对象 */
	imp: any;
	/**
	 * 构造函数。
	 * @param imp 内部实现对象
	 */
	constructor(imp?: object, isDestroyImp?: boolean);
	/**
	 * 复制对象的值
	 * @param val 双精度浮点数数组
	 * @example
	 * ```ts
	 * import { McGeDoubleArray } from "mxcad"
	 *
	  // array1 表示一个双精度浮点数数组
	  const array2 = new McGeDoubleArray();
	  array2.copy(array1);
  
	  // 现在array2与array1具有相同的值
	 * ```
	 */
	copy(val: McGeDoubleArray): this;
	/**
	* 添加一个值
	* @param val 双精度浮点数
	*/
	append(val: number): void;
	/**
	 * 返回数组长度
	 * @return 数组长度
	 */
	length(): number;
	/**
	 * 通过数组索引得到数据元素的值
	 * @param index 数组索引
	 */
	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;
	/**
	 * 清空数组
	 * */
	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;
}
/**
 * McGeBound 表示一个三维空间范围边界对象。
 *
 * @description
 * 该类用于描述一组点所围成的最小/最大边界，常用于计算包围盒、
 * 判断对象范围、进行视图缩放或几何分析。通过 addPoint / addPoints 可以不断扩展边界范围。
 *
 * @example
 * ```ts
 * import { McGeBound, McGePoint3d } from "mxcad";
 *
 * const bound = new McGeBound();
 * bound.addPoint(new McGePoint3d(0, 0, 0));
 * bound.addPoint(new McGePoint3d(10, 20, 5));
 *
 * console.log(bound.minPoint.x, bound.minPoint.y, bound.minPoint.z);//获取最小点
 * console.log(bound.maxPoint.x, bound.maxPoint.y, bound.maxPoint.z);//获取最大点
 * ```
 */
export declare class McGeBound {
	/**
	 *  最小点
	*/
	minPoint: McGePoint3d;
	/**
	 * 最大点
	 * */
	maxPoint: McGePoint3d;
	/**
	 * 是否有效
	  ```
	 * */
	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;
}
/** 坐标转换类型 ,该类只是为我们MxCAD的兼容的代码的调用，不会向用户导出
 * @ignore
*/
export declare class MxCoordConvertType {
	/** 文档坐标转cad坐标
	 * @param pt 三维点的对象
	 * @returns 三维点的对象
	*/
	doc2cad(pt: McGePoint3d): McGePoint3d;
	/** cad坐标转文档坐标
	 * @param pt 三维点的对象
	 * @returns 三维点的对象
	 * @example
	 */
	cad2doc(pt: McGePoint3d): McGePoint3d;
	/** 文档坐标转cad坐标
	 * @param pt THREE.js点对象
	 * @returns 三维点的对象
	 * @example
	 */
	doc2cad1(pt: THREE.Vector3): McGePoint3d;
	/** cad坐标转文档坐标
	 * @param x X轴坐标
	 * @param y Y轴坐标
	 * @param z Z轴坐标
	 * @returns 三维点的对象
	*/
	doc2cad2(x: number, y: number, z: number): McGePoint3d;
	/** cad坐标转文档坐标
	 * @param pt 三维点的对象
	 * @returns THREE.js点对象
	 */
	cad2doc1(pt: McGePoint3d): THREE.Vector3;
	/** cad坐标转文档坐标
	 * @param x X轴坐标
	 * @param y Y轴坐标
	 * @param z Z轴坐标
	 * @returns THREE.js点对象
	 * @example
	 * ```ts
	 * import { MxCpp, McGePoint3d } from 'mxcad';
	 * const mxcad = MxCpp.getCurrentCAD();
	 * let pt = mxcad.cad2doc2(20,0,0);
	 * console.log(pt)
	 * ```
	*/
	cad2doc2(x: number, y: number, z: number): THREE.Vector3;
}
/** 提供坐标转换方法,该类只是为我们MxCAD的兼容的代码的调用，不会向用户导出 */
export declare let MxCoordConvert: MxCoordConvertType;
/**
 * 检索一个CAD(计算机辅助设计)过滤器
 * @param filter 过滤器
 * @returns CAD过滤器imp
 */
export declare function getFilterImp(filter?: MxCADResbuf | null): any;
/**
 * MxCADResbuf 是一个用于构造和读取 CAD 规则数据的容器类。
 *
 * @description
 * 该类用于封装 AutoCAD / MxCAD 中的 resbuf 数据结构，常见于实体筛选、图层条件、扩展数据查询和对象选择等场景。
 * 它本质上更接近“数据规则集/条件容器”，用于把多种查询条件组织成统一的数据格式，再传递给选择集、命令交互、对象查询等功能；同时也能读取字符串、数值、点、对象 ID 等数据。
 * 使用方法：
 * 1. new MxCADResbuf() 创建条件容器；
 * 2. 调用 AddMcDbEntityTypes / AddString / AddPoint 等方法添加规则项；
 * 3. 将该容器传递给 MxCADSelectionSet.allSelect()、MxCADUtility.findEntAtPoint() 等接口；
 * 4. 使用 AtString / AtPoint / AtDouble / GetCount 等方法读取其中的数据。
 *
 * @example
 * ```ts
 * import { MxCADResbuf, MxCADSelectionSet } from "mxcad";
 *
 * // 创建条件容器，仅筛选直线和圆
 * const rules = new MxCADResbuf();
 * rules.AddMcDbEntityTypes("LINE,CIRCLE");
 *
 * const ss = new MxCADSelectionSet();
 * ss.allSelect(rules);
 * console.log("当前选择集对象数量：", ss.count());
 * ```
 */
export declare class MxCADResbuf extends McRxObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 * @example
	 * ```ts
	 * import { MxCADResbuf, DxfCode, MxCADSelectionSet } from "mxcad"
	 *
	 * let ss = new MxCADSelectionSet();
	 * // 定义筛选条件，限定实体类型：直线，圆弧，圆，多段线
	 * const filter1 = new MxCADResbuf([DxfCode.kEntityType, "LINE,ARC,CIRCLE,LWPOLYLINE"]));
	 * ss.allSelect(filter1);
	 *
	 * // 得到图上，直线，圆，圆弧，多段线，在0层上的对象.
	   const filter2 = new MxCADResbuf([DxfCode.kEntityType, "LINE,ARC,CIRCLE,LWPOLYLINE", DxfCode.kLayer, "0"]);
	   ss.allSelect(filter2);
	 * ```
	 */
	constructor(imp?: any);
	/**
	 * 清空 resbuf 数据。
	 */
	Clear(): void;
	/**
	 * 遍历数据。
	 * @param call 接受3个参数的回调函数（val:元素的值，type:元素类型，dxf:元素的数据交换格式）
	 * @example
	 * ```ts
	   import {MxCADResbuf} from "mxcad"

	   //创建MxCADResbuf实例
	   const cadResbuf = new MxCADResbuf();
	   cadResbuf.AddPoint(new McGePoint3d(1,2,3));//添加一个point元素
	   cadResbuf.AddString(“Hello”);//添加一个字符串元素
	   cadResbuf.AddDouble (3.14);//添加双精度型数据
	   cadResbuf.AddLong (42);//添加一个整型数据

	   //迭代CAD Resbuf实例中的元素
	   cadResbuf.forEach((val, type, dxf)=>{
		console.log("值:",val);
		console.log("类型:",type);
		console.log("DXF:",DXF);
		});
		//输出:
		//值:{x: 1, y: 2, z: 3}
		//类型:5009
		// dxf: 10
		//值:Hello
		//类型:5005
		// dxf: 10
		//取值:3.14
		//类型:5001
		// dxf: 10
		//取值:42
		//类型:5010
		// dxf: 10
	 * ```
	 */
	forEach(call: (val: any, type: number, dxf: number, index: number) => void): void;
	/**
	 * 获取 resbuf 数据项个数。
	 * @returns resbuf 数据项个数。
	 */
	GetCount(): number;
	/**
	 * 获取 resbuf 中所有点数据。
	 */
	GetPoints(): McGePoint3dArray;
	/**
	 * 获取 resbuf 数据项中的 double 类型值。
	 * @param lItem 数据项索引。
	 * @returns 包含 double 类型值和返回值的对象。
	 */
	AtDouble(lItem: number): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取 resbuf 数据项中的 long 类型值。
	 * @param lItem 数据项索引。
	 * @returns 包含 long 类型值和返回值的对象。
	 */
	AtLong(lItem: number): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取 resbuf 数据项中的 McRxObject 对象。
	 * @param lItem 数据项索引。
	 * @returns 包含 数据库对象和返回值的对象。
	*/
	AtObject(lItem: number): {
		val: McDbObject | undefined;
		ret: boolean;
	};
	/**
	 * 添加 McRxObject 对象到 resbuf 中
	 * @param pObj McRxObject示例对象
	 */
	AddObject(pObj: McRxObject): void;
	/**
	 * 获取 resbuf 数据项中的 ObjectId。
	 * @param lItem 数据项索引。
	 * @returns 包含 ObjectId 和返回值的对象。
	 */
	AtObjectId(lItem: number): {
		val: McObjectId;
		ret: boolean;
	};
	/**
	 * 获取 resbuf 数据项中的 ObjectId 值。
	 * @param lItem 数据项索引。
	 */
	AtObjectIdValue(lItem: number): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取 resbuf 数据项中的字符串。
	 * @param lItem 数据项索引。
	 * @returns 包含字符串和返回值的对象。
	 */
	AtString(lItem: number, decodeFromGb2312?: boolean): {
		val: string;
		ret: boolean;
	};
	/**
	 * 获取 resbuf 数据项中的点坐标。
	 * @param lItem 数据项索引。
	 * @returns 包含点坐标和返回值的对象。
	 */
	AtPoint(lItem: number): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 获取 resbuf 数据项中的数据类型。
	 * @param index 索引值
	 * @returns 数据类型。
	 */
	ItemDataType(index: number): number;
	/**
	 * 获取 resbuf 数据项中的数据的DXF值
	 * @param index 索引值
	 * @returns DXF值
	 */
	ItemDataDxf(index: number): number;
	/**
	 * 添加 double 类型值到 resbuf 中。
	 * @param val double 类型值。
	 * @param lDataType 数据类型。
	 * @returns 添加的数据项索引。
	 */
	AddDouble(val: number, lDataType?: number): number;
	/**
	 * 添加 long 类型值到 resbuf 中。
	 * @param val long 类型值。
	 * @param lDataType 数据类型。
	 * @returns 添加的数据项索引。
	 */
	AddLong(val: number, lDataType?: number): number;
	/**
	 * 添加 ObjectId 到 resbuf 中。
	 * @param val ObjectId。
	 * @param lDataType 数据类型。
	 * @returns 添加的数据项索引。
	 */
	AddObjectId(val: number | BigInt, lDataType?: number): number;
	/**
	 * 添加字符串到 resbuf 中。
	 * @param str 字符串。
	 * @param lDataType 数据类型。
	 * @returns 添加的数据项索引。
	 */
	AddString(str: string, lDataType?: number, decodeFromGb2312?: boolean): number;
	/**
	 * 添加扩展数据名，用于选择集规则筛选
	 * @param str 扩展数据名
	 * @param decodeFromGb2312 是否从GB2312编码解码，默认为true
	 * @returns 添加的数据项索引
	 */
	AddAppName(str: string, decodeFromGb2312?: boolean): number;
	/**
	 * 添加实体类型，用于选择集规则筛选
	 * @param str 多个类型用,连接 例如: "TEXT,MTEXT"
	 * @description 实体的类型表
	 * | 类型 | 描述 |
	 * | ------- | ------- |
	 * | POINT  | 文字  |
	 * | TEXT  | 文字  |
	 * | MTEXT  | 多行文字  |
	 * | CIRCLE  | 圆  |
	 * | ARC  | 圆弧  |
	 * | LINE  | 线  |
	 * | LWPOLYLINE | 多段线 |
	 * | INSERT | 图块 |
	 * | ELLIPSE | 椭圆 |
	 * | SPLINE | 样条线 |
	 * | LinkLine | 超链接 |
	 * @example
	 * ```ts
	 * import { MxCADResbuf } from "mxcad"
	 * // 定义筛选条件
	 * const filter = new MxCADResbuf()
	 * filter.AddMcDbEntityTypes ("TEXT,LINE");
	 * ```
	 */
	AddMcDbEntityTypes(str: string): any;
	/**
	 * 添加点坐标到 resbuf 中。
	 * @param pt 点坐标。
	 * @param lDataType 数据类型。
	 * @returns 添加的数据项索引。
	 */
	AddPoint(pt: McGePoint3d, lDataType?: number): number;
	/**
	 * 移除所有 resbuf 数据项。
	 */
	RemoveAll(): void;
	/**
	 * 移除指定索引的 resbuf 数据项。
	 * @param lItem 数据项索引。
	 */
	Remove(lItem: number): void;
	/**
	 * 调试输入信息
	 */
	PrintData(): void;
}
/**
 * MxCADUtilityClass 是 MxCAD 的通用工具类，提供对象选择、图形查询、删除和高亮等常用操作。
 *
 * @description
 * 该类用于封装和简化 CAD 视图中的常用交互与查询能力，例如：按点查找实体、选择对象、获取当前选中项、删除对象、设置对象高亮等。
 * 它是 CAD 二次开发中最常用的工具入口之一，适合实现交互式编辑、对象识别和图形操作。
 * 使用方法：
 * 1. 通过 MxCADUtility 直接调用 selectEnt / findEntAtPoint / getCurrentSelect 等方法；
 * 2. 传入规则容器 MxCADResbuf 来限制查询范围；
 * 3. 获取到 McObjectId 后，可以继续调用 getMcDbEntity() 读取实体对象；
 * 4. 通过 highlightEntity()、eraseObject() 等方法完成对象操作。
 *
 * @example
 * ```ts
	import { MxCADUtility, MxCADUiPrPoint } from "mxcad";

	async function test() {
	const getPoint = new MxCADUiPrPoint();
	getPoint.setMessage("请选择图上对象");
	const point = await getPoint.go();
	if (!point) return;

	// 查找指定点附近的图形对象
	const objId = MxCADUtility.findEntAtPoint(point.x, point.y, point.z, -1, null);
	if (objId.isValid()) {
		// 高亮显示命中的对象
		MxCADUtility.highlightEntity(objId.id, true);
		console.log("命中对象：", objId);
	}
	}
 * ```
 */
export declare class MxCADUtilityClass {
	/** 内部实现对象 */
	private imp;
	constructor();
	/**
	 * eraseObject 方法用于删除指定的图形对象
	 * @param lId - 需要删除的图形对象的 ID
	 * @param isErase - 是否需要删除，默认为 true
	 * @returns 返回一个布尔值，表示是否删除成功
	 * @example
	 * ```ts
	  import { MxCpp, McGePoint3d, McDbLine, MxCADUtility } from "mxcad";
	  
	  const line = new McDbLine(new McGePoint3d(0,0,0), new McGePoint3d(20,1,0));
	  const lineId = MxCpp.getCurrentMxCAD().drawEntity(line);
	  const res = MxCADUtility.eraseObject(lineId.id)
	  console.log("删除结果：", res);
	 * ```
	 */
	eraseObject(lId: number, isErase?: boolean): boolean;
	/**
	 * highlightEntity 方法用于高亮指定的图形对象
	 * @param lId - 需要高亮的图形对象的 ID
	 * @param isHighlight - 是否需要高亮，默认为 true
	 */
	highlightEntity(lId: number, isHighlight?: boolean): any;
	/**
	 * findEntAtPoint 方法用于在指定坐标点附近查找图形对象
	 * @param dX - 坐标点的 X 坐标值
	 * @param dY - 坐标点的 Y 坐标值
	 * @param dZ - 坐标点的 Z 坐标值
	 * @param dSearhRange - 设置选取范围，默认为 -1  表示自适应，或者输入对应的CAD坐标长度
	 * @param filter - 筛选条件对象，用于限定查找到的图形对象范围，默认为 null（表示不做限制）
	 * @returns 返回查找到的图形对象的 ID
	 * @example
	 * ```ts
	   import { MxCADUiPrPoint, MxCADUtility, MxCpp } from "mxcad"
	   
	   async function test(){
		const mxcad = MxCpp.getCurrentCAD();
		const getPoint = new MxCADUiPrPoint();
		getPoint.setMessage('请选择对象\n');
		const point = await getPoint.go();
		if (!point) break;
		const filter = new MxCADResbuf([DxfCode.kEntityType, "LINE,ARC,CIRCLE,LWPOLYLINE"]));
		let objId = MxCADUtility.findEntAtPoint(point.x, point.y, point.z, -1, filter);
		mxcad.addCurrentSelect(objId);
	   }
	 * ```
	 */
	findEntAtPoint(dX: number, dY: number, dZ: number, dSearhRange?: number, filter?: MxCADResbuf | null): McObjectId;
	/**
	 * selectEnt 方法用于在指定位置选择图形对象
	 * @param strPrompt - 选择时的提示信息，默认为 null（表示不显示提示信息）
	 * @param filter - 筛选条件对象，用于限定选择到的图形对象范围，默认为 null（表示不做限制）
	 * @param isSelectMxDraw 是否选择批注图形 默认true
	 * @param init 选择图形前初始化函数( 会在实例化{@link https://mxcadx.gitee.io/mxdraw_api_docs/classes/MrxDbgUiPrPoint.html | mxdraw取点类}时触发，得到取点实例)
	 * @param callbackGetPoint 回调函数 获取选中图形时的坐标点
	 * @returns 返回一个 Promise，其中包含选择到的图形对象的 ID 数组
	 * @example
	 * ```ts
	 * import { MxCADUtility, MxCADResbuf } from "mxcad";
	 *
	 * async function selectTargetEntity() {
	 *   // 限定只允许选择直线、圆、圆弧和多段线
	 *   const filter = new MxCADResbuf();
	 *   filter.AddMcDbEntityTypes("LINE,CIRCLE,ARC,LWPOLYLINE");
	 *
	 *   // 通过交互式方式让用户在图纸上选择对象
	 *   const ids = await MxCADUtility.selectEnt(
	 *     "请选择目标对象",
	 *     filter,
	 *     true,
	 *     (getPoint) => {
	 *       getPoint.setMessage("请点击图上的目标对象");
	 *       getPoint.setDisableOsnap(true);
	 *     },
	 *     (pt) => {
	 *       console.log("点击位置：", pt.x, pt.y, pt.z);
	 *     }
	 *   );
	 *
	 *   if (ids.length === 0) {
	 *     console.log("未选中任何对象");
	 *     return;
	 *   }
	 *
	 *   console.log("已选择对象 ID：", ids);
	 *   for (const id of ids) {
	 *     const ent = id.getMcDbEntity();
	 *     if (ent) {
	 *       console.log("对象类型：", ent.objectName);
	 *     }
	 *   }
	 * }
	 *
	 * ```
	 */
	selectEnt(strPrompt?: string, filter?: MxCADResbuf | null, isSelectMxDraw?: boolean, init?: (getPoint: MrxDbgUiPrPoint) => any, callbackGetPoint?: (point: McGePoint3d) => void): Promise<McObjectId[]>;
	/**
	* 得到图上当前选择对象时，选择范围点。
	* @returns { object } point1 角点1 | point2 角点2 | isvalid 是否有效
	*/
	getCurrentSelectPoints(): {
		point1: McGePoint3d;
		point2: McGePoint3d;
		isvalid: boolean;
	};
	/**
   * 得到当前选中的对象。
   * @param filter 筛选条件对象
   */
	getCurrentSelect(filter?: MxCADResbuf | null | Object, returnMxCADObject?: boolean, returnMxDrawObject?: boolean, whenEmptyReturnPrvSelect?: boolean, isFilterLockLayer?: boolean): McObjectId[];
	/** 用户选择
	 * @param strPrompt 字符串提示
	 * @param filter 筛选条件对象
	 * @returns 返回一个 Promise，其中包含得到选择的对象ID
	 * @example
	 * ```ts
		import { MxCADResbuf, MxCADUtility } from 'mxcad';
		let filter = new MxCADResbuf();
		filter.AddMcDbEntityTypes("CIRCLE,ARC,LINE,LWPOLYLINE,ELLIPSE");
		let aryId = await MxCADUtility.userSelect("选择目标曲线", filter);
		console.log(aryId);
	 * ```
	 *  */
	userSelect(strPrompt?: string | Object, filter?: MxCADResbuf | null, init?: (ss: MxCADSelectionSet, getPoint: MrxDbgUiPrPoint) => any, isRetCurrentSelect?: boolean, isFilterLockLayer?: boolean): Promise<McObjectId[]>;
	/**
	 * 初始化
	 * */
	init(): void;
	/** 获取角点(鼠标点击的两个点)
	 * @param strPrompt 字符串提示
	 * @param pt1 第一个点 (已知一个角点的情况)
	 * @param detailedResult {@link DetailedResult} 交互结果讲台的回调
	 * @param drawSelectCroner 绘制选择对象的选框(true有背景false无背景)
	 * @param isDisableAllTrace 是否禁用所有跟踪
	 * @returns 返回一个 Promise，其中包含两个角点对象
	 * @example
	 * ```ts
	 * import { MxCADUtility } from "mxcad";
	 *
	 * const ret = await MxCADUtility.getCorner("测试");
	 * if (!ret) return;
	 * console.log(ret.pt1, ret.pt2)
	 * pt4----pt2
	 * |       |
	 * pt1----pt3
	 * ```
	 *  */
	getCorner(strPrompt?: string, pt1?: McGePoint3d, detailedResult?: (retcode: DetailedResult) => any, drawSelectCroner?: boolean, isDisableAllTrace?: boolean, init?: (getPoint: MxCADUiPrPoint) => any): Promise<{
		pt1: McGePoint3d;
		pt2: McGePoint3d;
		pt3: McGePoint3d;
		pt4: McGePoint3d;
	} | null>;
	/** 获取多个实体形成的包围盒
	 * @param aryId 实体对象ID数组
	 * @returns { object} minPt 最小点 | maxPt 最大点
	 * @example
	 * ```ts
	   import { MxCADUtility } from "mxcad";
	 *
	   async function test(){
		let aryId = await MxCADUtility.userSelect("选择目标对象");
		let ext = MxCADUtility.getMcDbEntitysBoundingBox(aryId);
		if (!ext) return;
		console.log("最小点"，ext.minPt)
		console.log("最大点", ext.maxPt)
	   }
	 * ```
	 *  */
	getMcDbEntitysBoundingBox(aryId: McObjectId[]): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
	} | undefined;
	/** 计算凸度
	 * @param pt1 开始点
	 * @param pt2 中点
	 * @param pt3 结束点
	 * @returns 计算凸度结果
	 * @example
	 * ```ts
	 * import { McGePoint3d, MxCADUtility } from "mxcad"
	 *
	 * const pt1 = new McGePoint3d(0,0,0);
	 * const pt2 = new McGePoint3d(20,10,0);
	 * const pt3 = new McGePoint3d(40,0,0);
	 * const Bulge = MxCADUtility.calcBulge(pt1, pt2, pt3);
	 * console.log(Bulge)
	 * ```
	 *  */
	calcBulge(pt1: McGePoint3d, pt2: McGePoint3d, pt3: McGePoint3d): {
		val: number;
		ret: boolean;
	};
	/** 判断一个点是否在闭合区域内
	 *  */
	pointInPolygon(aryPoint: McGePoint3dArray, x: number, y: Number): boolean;
	/** 通过一个点坐标填充对应位置实体的填充
	 * @param pt 点对象
	 * @returns 返回一个填充对象
	 * @example
	 * ```ts
	   import { MxCADUiPrPoint, MxCADUtility } from 'mxcad'
	
	   async function test(){
		const getPoint = new MxCADUiPrPoint();
		getPoint.setMessage("\n指定填充区域内部一点:");
		getPoint.disableAllTrace(true);
		getPoint.setDisableOsnap(true);
		let pt = (await getPoint.go()) as McGePoint3d;
		if (!pt) return;

		let hatch = MxCADUtility.builderHatchFromPoint(pt);
		MxCpp.mxcad.drawEntity(hatch);
	   }
	 * ```
	 * */
	builderHatchFromPoint(pt: McGePoint3d): McDbHatch | null;
	/**
	 * 计算文字的外包框
	 * @example
	 * ```ts
	 * import { MxCADUtility, MxCpp } from "mxcad"
	 * // 获取当前字体样式下文字空格符号的大小
	 * const { minPt.maxPt, ret} = MxCADUtility.getTextBox(" ", 100, 1.0, MxCpp.getCurrentDatabase().getCurrentlyTextStyleId());
	 * if(ret){
	 * console.log("最小点", minPt)
	 * console.log("最大点", maxPt)
	 * }
	 * ```
	 * */
	getTextBox(str: string, dTextHeight: number, dWidthFactor: number, idTextStyleRecord: McObjectId): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 计算文字对象的外包框
	 * @example
	 * ```ts
	 * import { MxCpp, MxCADUtility, } from "mxcad";
	 *
	 * async function test(){
		let mxcad = MxCpp.getCurrentMxCAD();
		let retIds = await MxCADUtility.selectEnt("选择");
		if (retIds.length == 0) {
			return;
		}
		let id = retIds[0];
		let ent = id.getMcDbEntity();
		if (ent) {
			let box = MxCADUtility.getTextEntityBox(ent, false);
			if (box.ret) {
				mxcad.drawLine(box.maxPt.x, box.maxPt.y, box.minPt.x, box.minPt.y);
			}
		}
	 * }
	 * ```
	 * */
	getTextEntityBox(text: McDbEntity, isTrimLastSpace?: boolean): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
		ret: boolean;
	};
}
/** 提供了一系列与绘图相关的工具方法 */
export declare let MxCADUtility: MxCADUtilityClass;
/** 选择集状态枚举 */
export declare enum MxCADSelectionSetStatus {
	/** 构造选择集成功 */
	kSelected = 0,
	/** 当交互构造选择集时，用户直接按下了 Enter 键。 */
	kNone = 1,
	/** 当交互构造选择集时，用户按下了 Esc 键取消。 */
	kCanceled = 2,
	/** 拒绝执行的无效请求(关键字错误)。 */
	kRejected = 3,
	/** 输入了关键值 */
	kKeyword = 4
}
/**
 * MxCADSelectionSet 是一个用于管理和遍历当前选择集中对象的集合类。
 *
 * @description
 * 该类用于执行对象选择、筛选、遍历和批量处理，适用于 CAD 图形编辑场景中的“选中对象查询”和“批量操作”。
 * 通过它可以执行全选、点选、框选、用户交互选择，并获取选择集中的对象 ID，随后再调用 getMcDbEntity() 获取实体实例。
 * 使用方法：
 * 1. new MxCADSelectionSet() 创建选择集；
 * 2. 调用 allSelect() / pointSelect() / userSelect() 等方法进行选择；
 * 3. 使用 count()、item()、forEach()、getIds() 读取或遍历结果；
 * 4. 对选中的对象继续执行高亮、删除、修改属性等后续操作。
 *
 * @example
 * ```ts
 * import { MxCADResbuf, MxCADSelectionSet } from "mxcad";
 *
 * const ss = new MxCADSelectionSet();
 * const filter = new MxCADResbuf();
 * filter.AddMcDbEntityTypes("LINE,CIRCLE");
 *
 * ss.allSelect(filter);
 * console.log("已选对象数：", ss.count());
 *
 * ss.forEach((id) => {
 *   const ent = id.getMcDbEntity();
 *   if (ent) console.log("实体：", ent.objectName);
 * });
 * ```
 */
export declare class MxCADSelectionSet extends McRxObject {
	/**
	 * 是否循环选择
	 * */
	isWhileSelect: boolean;
	/**
	 * 选择是否高亮
	 * */
	isSelectHighlight: boolean;
	/**
	 * 是过滤掉锁定的图层
	 * */
	get isFilterLockLayer(): boolean;
	set isFilterLockLayer(val: boolean);
	private selectPoints;
	/**
	 * 构造函数
	 * */
	constructor();
	/**
	 * 得到选择形成的两个对角点
	 * @returns {object} pt1 角点1 | pt2 角点2
	 * */
	getSelectPoint(): {
		pt1: McGePoint3d;
		pt2: McGePoint3d;
	};
	/**
	* 返回选择点数组。
	* @returns 选择框点数组
	* */
	getSelectPoints(): McGePoint3d[];
	/** 全选
	 * @param filter 筛选条件对象
	 * @example
	 * ```ts
	   import { MxCADSelectionSet } from "mxcad";
	
	   let ss = new MxCADSelectionSet();
	   ss.allSelect();
	   ss.forEach((id) => {
			let ent: any = id.getMcDbEntity();
			if (!ent) return;
			ent = McDbEntityToJsonObject(ent);
			console.log(JSON.stringify(ent));
		})
	 * ```
	 * @example
	 * ```ts
		import { MxCADSelectionSet } from "mxcad";
		let ss = new MxCADSelectionSet();
		// 得到图上，直线，圆，圆弧，多义线，在0层上的对象.
		ss.allSelect(new MxCADResbuf([DxfCode.kEntityType, "LINE,ARC,CIRCLE,LWPOLYLINE",DxfCode.kLayer,"0"]));
		console.log("得到对象数目:" + ss.count());
	 * ```
	 * @example
	 * ```ts
	 *    import { MxCADSelectionSet } from "mxcad";
	 *    let ss = new MxCADSelectionSet();
	 *    // 得到0层上的对象.
	 *    ss.allSelect(new MxCADResbuf([DxfCode.kLayer,"0"]));
	 *    console.log("得到对象数目:" + ss.count());
	 *    // 遍历对象
	 *     ss.forEach((id) => {
	 *    let ent = id.getMcDbEntity();
	 *    if (!ent) return;
	 *    let entBox = ent.getBoundingBox();
	 *  })
	 * ```
	 *  */
	allSelect(filter?: MxCADResbuf | null): number;
	/** 根据一个坐标点选择一个实体对象的索引
	 * @param dX 坐标x
	 * @param dY 坐标y
	 * @param filter 筛选条件对象
	 * @return 实体对象索引
	 * @example
	 * ```ts
		import { MxCADSelectionSet, MxCADResbuf } from "mxcad"

		// 通过单个点选择
		const ss = new MxCADSelectionSet();
		const filter = new MxCADResbuf();
		// 添加对象类型，选择集只选择文字类型的对象
		filter.AddMcDbEntityTypes("TEXT,MTEXT")
		const getPoint = new MxCADUiPrPoint()
		const point = await getPoint.go()
		if (!point) return;
		// 加filter过滤选择集, 这里只会选择文字对象
		const index = ss.pointSelect(point.x, point.y, filter)
		const objId = ss.item(index)
		const ent = objId.getMcDbEntity()
		console.log(ent)
	 * ```
	 *  */
	pointSelect(dX: number, dY: number, filter?: MxCADResbuf | null, dTol?: number): number;
	/** 根据两个对角点选择一个实体对象的索引
	 * @param dX1 角点1 X轴值
	 * @param dY1 角点1 Y轴值
	 * @param dX2 角点2 X轴值
	 * @param dY2 角点2 Y轴值
	 * @param filter 筛选条件对象
	 * @return 实体对象索引
	 *  */
	crossingSelect(dX1: number, dY1: number, dX2: number, dY2: number, filter?: MxCADResbuf | null): number;
	/**
	 * 获取当前选中的个数
	 * @return 当前选中实体个数
	 * */
	count(): number;
	/**
	 * 判断选择集是否为空
	 * @return 布尔值
	 * */
	isNull(): boolean;
	/** 根据对象索引 得到对应对象ID
	 * @param lItem 对象索引
	 * @return 对象id
	 * @example
	 * ```ts
	  import { MxCADSelectionSet } from "mxcad";
	  // 全选图纸上的代理实体
		async function TestGetProx() {
			let ss = new MxCADSelectionSet();
			let filter = new MxCADResbuf();
			filter.AddString("ACAD_PROXY_ENTITY", 5020)
			ss.allSelect(filter);
			let iCount = ss.count();
			for (let i = 0; i < iCount; i++) {
				let ent = ss.item(i).getMcDbEntity();
				if (!ent) continue;
				console.log(ent);
			}
	   }
	 * ```
	 * */
	item(lItem: number): McObjectId;
	/**
	 * 清空选择集
	 * */
	clear(): void;
	/** 遍历已选中的实体
	 * @example
	 * ```ts
	   import { MxCADSelectionSet } from "mxcad";
	 *
	   let ss = new MxCADSelectionSet();
	   ss.allSelect();
	   ss.forEach((id) => {
		   let ent: any = id.getMcDbEntity();
	   })
	 * ```
	 * */
	forEach(call: (val: McObjectId) => void): void;
	/** 得到当前已选中的所有对象ID
	 * @returns 选中id对象数组
	 * */
	getIds(): McObjectId[];
	/** 得到当前已经选择的对象
	 * @returns 选中id对象数组
	 * */
	currentSelect(filter?: MxCADResbuf | null): number;
	/** 用户选择
	 * @param  strPrompt 字符串提示
	 * @param filter 筛选条件
	 * @param init 用户选择前的初始化操作
	 * @example
	 * ```ts
	   import { MxCADResbuf, MxCADSelectionSet } from "mxcad";
	
	   function test(){
		let filter = new MxCADResbuf();
		filter.AddMcDbEntityTypes("INSERT");
		let ss = new MxCADSelectionSet();
		if (!await ss.userSelect("选择要刷的目标块:", filter)) return;
		if (ss.count() == 0) return;
		let ids = ss.getIds();
		console.log(ids);
	   }
	 * ```
	 *  */
	userSelect(strPrompt?: string | Object, filter?: MxCADResbuf | null, init?: (getPoint: MrxDbgUiPrPoint) => any): Promise<boolean>;
	/**
	 * 按栅栏方式选择图上的对象
	 * @param strPrompt 交互提示信息，可为空。
	 * @param filter 筛选条件对象，用于限制可选对象类型，默认为 null。
	 * @param init 用户选择前的初始化回调，可在这里设置提示消息和交互参数。
	 * @returns 返回一个 Promise，当用户完成栅栏选择并确认时返回 true，取消或退出时返回 false。
	 */
	fenceSelect(strPrompt?: string, filter?: MxCADResbuf | null, init?: (getPoint: MrxDbgUiPrPoint) => any): Promise<boolean>;
}
/**
 * 交互取点基类，封装用户交互输入的通用功能。
 * @description
 * `MxCADUiPrBase` 是所有 `MxCADUiPr*` 系列交互类的抽象基础，封装了与用户交互取点、关键字输入、
 * 动态绘制、提示信息、捕捉设置等常用行为。子类通常通过传入不同的内部实现（如 `MrxDbgUiPrPoint`、
 * `MrxDbgUiPrDist` 等）来实现具体的交互语义，但共享如下能力：
 * - 设置/获取提示消息（`setMessage` / `message`）
 * - 管理关键字列表与检测用户选择（`setKeyWords` / `keyWordPicked` / `isKeyWordPicked`）
 * - 设置动态绘制回调以在交互过程中绘制临时图形（`setUserDraw`）
 * - 获取交互结果的详细退出原因与类型（`getDetailedResult` / `getStatus` / `getResultPointType`）
 * - 控制动态输入、极轴/格网/捕捉等跟踪行为（`setDisableDynInput` / `setDisablePolarAxisTrace` 等）
 *
 * 使用方法:
 * 1. 直接使用已有子类（如 `MxCADUiPrPoint`、`MxCADUiPrDist` 等）完成具体取点/取距操作；
 * 2. 或通过继承 `MxCADUiPrBase` 并传入自定义内部实现（imp）来实现新的交互控件；
 * 3. 在交互前设置提示、关键字、动态绘制回调等，调用子类的 `go()` 方法获取用户输入。
 *
 * @example
 * ```ts
 * import { MxCADUiPrPoint } from 'mxcad';
 *
 * async function example() {
 *   const getPoint = new MxCADUiPrPoint();
 *   getPoint.setMessage('\n指定第一个点:');
 *   getPoint.setUserDraw((pt, worldDraw) => {
 *     // 在动态绘制回调中绘制临时标记
 *     worldDraw.drawCircle(pt.toVector3(), 10);
 *   });
 *   const pt = await getPoint.go();
 *   if (!pt) return;
 * }
 * ```
 */
export declare class MxCADUiPrBase {
	/** 内部实现对象 */
	protected imp: any;
	/** MxDraw 实例对象 */
	protected mxobj: MxDrawObject;
	/** 构造函数
	 * @param imp 内部实现对象
	 */
	constructor(imp: any);
	/** 文档坐标转cad坐标
	 * @param pt THREE.js坐标
	 * @returns 三维点对象
	 */
	protected doc2cad1(pt: THREE.Vector3): McGePoint3d;
	/** 文档坐标转cad坐标
	 * @param x X轴值
	 * @param y Y轴值
	 * @param z Z轴值
	 * @returns 三维点对象
	 */
	protected doc2cad2(x: number, y: number, z: number): McGePoint3d;
	/** cad坐标转文档坐标
	 * @param pt 三维点对象
	 * @returns THREE.js点对象
	 */
	protected cad2doc1(pt: McGePoint3d): THREE.Vector3;
	/** cad坐标转文档坐标
	 * @param x X轴值
	 * @param y Y轴值
	 * @param z Z轴值
	 * @returns THREE.js点对象
	 */
	protected cad2doc2(x: number, y: number, z: number): THREE.Vector3;
	/**
   * 返回关键字列表
   * @returns 关键词列表
   * @example
   * ```ts
   * //以 MxCADUiPrPoint 类示例，其他MxCADUiPr* 系列的类同理
	 import { MxCADUiPrPoint } from 'mxcad'
	 const getPoint = new MxCADUiPrPoint();
	 getPoint.setKeyWords("[选项1(A)/选项2(B)]");
	 const keyList = getPoint.keyWords();
	 console.log("关键词列表", keyList)// 关键词列表 [选项1(A)/选项2(B)]
   * ```
   */
	keyWords(): string;
	/**
	 * 设置关键字列表
	 * @param keyWordList 关键词列表
	 * @returns void
	 * @example
	 * ```ts
	   //以 MxCADUiPrPoint 类示例, 其他MxCADUiPr* 系列的类同理
	   import { MxCADUiPrPoint } from 'mxcad'
	   const getPoint = new MxCADUiPrPoint();
	   getPoint.setKeyWords("[选项1(A)/选项2(B)]")
	 * ```
	 */
	setKeyWords(keyWordList: string): void;
	/**
	 * 清除上一次的输入点数据。
	*/
	clearLastInputPoint(): void;
	/**
	 * 设置上一次的输入点。
	 * @param pt 点对象
	 */
	setLastInputPoint(pt: McGePoint3d | undefined): void;
	/**
   * 返回上一次的输入点。
   * @returns 选择的关键字
   */
	getLastInputPoint(): McGePoint3d | undefined;
	/**
	 * 提示字符串
	 * @returns 提示消息
	 */
	message(): string;
	/**
	 * 设置提示字符串
	 * @param message 提示消息
	 * @returns 提示消息
	 */
	setMessage(message: string): void;
	/**
	 * 返回用户选择的关键字
	 * @returns 选择的关键字
	 * @example
	 * ```ts
	   //以 MxCADUiPrPoint 类示例
	   import { MxCADUiPrPoint } from 'mxcad';
	 *
	   async function test(){
		const getPoint = new MxCADUiPrPoint();
		getPoint.setKeyWords("[选项1(A)/选项2(B)]");
		const pt = await getPoint.go();
		const key = getPoint.keyWordPicked();
		console.log(key)
	   }
	 * ```
	 */
	keyWordPicked(): string;
	/**
	 * 测试某一个关键字是否被用户选择
	 * @param matchKeyWord 要检测的关键字
	 * @returns true为真
	 * @example
	 * ```ts
	   //以 MxCADUiPrPoint 类示例
	   import { MxCADUiPrPoint } from 'mxcad';
	 *
	  async function test(){
		const getPoint = new MxCADUiPrPoint();
		getPoint.setKeyWords("[选项1(A)/选项2(B)]");
		const pt = await getPoint.go();
		if(getPoint.isKeyWordPicked('A')){
			console.log('选项1')
		}else if(getPoint.isKeyWordPicked('B')){
			console.log('选项2')
		}
	  }
	 * ```
	 */
	isKeyWordPicked(matchKeyWord: string): boolean;
	/**
	 * 设置交互过程的动态绘制调用对象
	 * @param pDraw {@link McEdGetPointWorldDrawObject | 动态绘制调用对象}
	 * @returns void
	 * @example
	 * ```ts
	 * //以 MxCADUiPrPoint 类示例
	   import { MxCADUiPrPoint } from 'mxcad';
	 *
	   async function test(){
		const getPoint = new MxCADUiPrPoint();
		getPoint.setUserDraw((pt,pw)=>{
			pw.setColor(0xff00ff);
			pw.drawCircle(new HTREE.Vector3(pt.x,pt.y,pt.z), 10)
		})
		const pt = await getPoint.go();
		console.log("point", pt)
	   }
	 * ```
	 */
	setUserDraw(pDraw: ((currentPoint: McGePoint3d, pWorldDraw: McEdGetPointWorldDrawObject) => void)): void;
	/**
	* 返回交互操作退出的详细原因
	* @returns 当前交互操作返回值类型
	* @example
	* ```ts
	* //以 MxCADUiPrDist 类示例
	  import { MxCADUiPrDist } from 'mxcad';
	  import { DetailedResult } from "mxdraw";
	*
	  async function test(){
		const getDist = new MxCADUiPrDist();
		const val = await getDist.go();
		if (!val) return;
		if (getDist.getDetailedResult() === DetailedResult.kCoordIn) {
			console.log('提示输入', val)
		}
	  }
	* ```
	*/
	getDetailedResult(): DetailedResult;
	/**
	 * 返回交互取点操作得到的点类型
	 */
	getResultPointType(): AcquirePointType;
	/**
	 * 返回交互取点操作得到的点的捕捉类型
	 */
	getResultPointOsnapMode(): AcquirePointOsnapMode;
	/**
	 * 获取操作状态
	 * @return 操作状态值
	* @example
	* ```ts
	* //以 MxCADUiPrDist 类示例
	  import { MxCADUiPrDist } from 'mxcad';
	  import { MrxDbgUiPrBaseReturn } from "mxdraw";
	*
	  const getDist = new MxCADUiPrDist();
	  const val = await getDist.go();
	  if (!val) return;
	  if(getPoint.getStatus() === MrxDbgUiPrBaseReturn.kNone) {
		// 空输入
	  }
	* ```
	 * */
	getStatus(): MrxDbgUiPrBaseReturn;
	/**
	 * 把动态绘制的对象，保留到图上。
	 * @param callAddEntity 回调参数ent 类型：THREE.THREE.Object3D
	 * @example
	 * ```ts
	 * //以 MxCADUiPrPoint 类示例
	  import { MxCADUiPrPoint } from 'mxcad';
	*
	  async function test(){
		const getPoint = new MxCADUiPrPoint();
		const basePt = new McGePoint3d(0, 0, 0);
		getPoint.setBasePt(basePt);
		getPoint.setUserDraw((pt,pw)=>{
		const line = new McDbLine(basePt, pt);
		pw.drawMcDbEntity(line)
		})
		const val = await getPoint.go();
		if (!val) return;
		getPoint.drawReserve()
	  }
	 * ```
	 */
	drawReserve(callAddEntity?: (ent: THREE.Object3D) => void): void;
	/**
	 * 设置需要的Touche输入类型,默认值是 {@link MxType.InputToucheType.kGetBegan}
	 * @param toucheType toucheType类型
	 * @example
	 * ```ts
	 * //以 MxCADUiPrPoint 类示例
	   import { MxCADUiPrPoint, MxCpp } from "mxcad";
	   import { MxType } from "mxdraw";
	 *
		// 手机触模屏画直线
		async function Mx_Test_Touch_DrawLine() {
			const getPoint = new MxCADUiPrPoint();
			getPoint.setOffsetInputPostion(true);
			getPoint.setMessage("\n指定第一点:");
			// 接收 kGetBegan,触摸屏手指按下.
			getPoint.setInputToucheType(MxType.InputToucheType.kGetEnd);
			let pt1 = await getPoint.go();
			if (!pt1) return;
			getPoint.setMessage("\n指定第二点:");
			getPoint.setBasePt(pt1);

			console.log(getPoint.getResultPointOsnapMode());
			console.log(getPoint.getResultPointType());

			// 接收kGetEnd,触摸屏手指放开.
			getPoint.setInputToucheType(MxType.InputToucheType.kGetEnd);
			let pt2 = await getPoint.go();
			if (!pt2) return;
			let mxcad = MxCpp.getCurrentMxCAD();
			let ent = mxcad.drawLine(pt1.x, pt1.y, pt2.x, pt2.y).getMcDbEntity();
			if (ent) {
				ent.lineweight = 20;
			}
		}
	 * ```
	 */
	setInputToucheType(toucheType: number): void;
	/**
	 * 返回需要的Touche输入类型
	 * @returns Touche输入类型
	 */
	getInputToucheType(): number;
	/**
	 * 设置光标类型
	 * @param type 鼠标样式类型
	 * @example
	 * ```ts
	 * //以 MxCADUiPrPoint 类示例
	   import { MxCADUiPrPoint } from 'mxcad';
	   import { MxCursorType } from "mxdraw";
	 *
	   async function test(){
		const getPoint = new MxCADUiPrPoint()
		getPoint.setMessage("指定文字起点:")
		getPoint.setCursorType(MxCursorType.kCross);
		const pt = await getPoint.go();
	   }
	 * ```
	 */
	setCursorType(type: MxCursorType): void;
	/**
	 * 返回光标类型
	 */
	getCursorType(): MxCursorType;
	/**
	 * 设置动态输入类型
	 * @param type 动态输入显示类型
	 * @example
	 * ```ts
	 * //以 MxCADUiPrPoint 类示例
	   import { MxCADUiPrPoint } from 'mxcad';
	   import { DynamicInputType } from "mxdraw";
	 *
	   async function Mx_WindowZoom() {
		 let getPoint = new MxCADUiPrPointTransform(MxInsidePublicFuns.getMxCADViewSpinMatrix(MxCpp.getCurrentMxCAD()));
		 getPoint.disableAllTrace();
		 getPoint.setMessage("\n点取缩放区域");
		 getPoint.setDynamicInputType(DynamicInputType.kDynTip);
		 let pt1 = await getPoint.go();
		 if (pt1 == null) return;
		 let mxcad = MxCpp.getCurrentMxCAD();
		 getPoint.setUserDraw((p1, worldDraw) => {
			 worldDraw.drawRect(MxCoordConvert.cad2doc1((pt1 as any)), MxCoordConvert.cad2doc1((p1 as any)));
		 });

		 let pt2 = await getPoint.go();
		 if (pt2 == null) return;

		 pt1.transformBy(getPoint.rmat);
		 pt2.transformBy(getPoint.rmat);
		 mxcad.zoomW(pt1, pt2);
	  }
	 * ```
	 */
	setDynamicInputType(type: DynamicInputType): void;
	/**
	 * 返回动态输入类型
	 * @returns 动态输入显示类型
	 */
	getDynamicInputType(): DynamicInputType;
	/**
	 * 是否禁用动态输入框
	*/
	isDisableDynInput(): boolean;
	/**
	 * 设置是否禁用动态输入框
	 * @param isDisable 是否禁用
	 */
	setDisableDynInput(isDisable: boolean): void;
	/**
	 * 设置是否禁用捕捉
	 * @param isDisable 是否禁用
	 */
	setDisableOsnap(isDisable: boolean): void;
	/**
	* 设置捕捉时的扩展捕捉参数。
	* @param lVal 扩展对象捕捉参数
	* @example
	* ```ts
	* import { MxCADUiPrPoint } from "mxcad";
	* import { OsModeExParam } from "mxdraw";
	*
		async function Mx_Test_Rect2() {
			const getPoint = new MxCADUiPrPoint();
			getPoint.clearLastInputPoint();
			getPoint.setMessage("请选择第一个点");
			const pt1 = await getPoint.go();
			if (!pt1) return;

			const getNextPt = new MxCADUiPrPoint();
			getNextPt.setMessage("请选择第二个角点");
			getNextPt.setOsModeExParam(OsModeExParam.kCircleTangentOsmode);
			getNextPt.setUserDraw((pt2, pWorldDraw) => {
				let pl = new McDbPolyline();
				pl.addVertexAt(pt1);
				pl.addVertexAt(new McGePoint3d(pt1.x, pt2.y, pt1.z));
				pl.addVertexAt(pt2);
				pl.addVertexAt(new McGePoint3d(pt2.x, pt1.y, pt1.z));
				pl.isClosed = true;
				pWorldDraw.drawMcDbEntity(pl);
			});

			if (!await getNextPt.go()) return;

			getNextPt.drawReserve();
		}
	* ```
	*/
	setOsModeExParam(lVal: OsModeExParam): void;
	/**
	 * 是否禁用捕捉
	 */
	isDisableOsnap(): boolean;
	/**
	 * 输入点是否偏移显示/处理
	 */
	isOffsetInputPostion(): boolean;
	/**
	 * 设置输入点遍移，常用于移动端取点
	 * @example
	 * ```ts
	 * import { MxCADUiPrPoint } from "mxcad";
	 * import { MxFun } from "mxdraw";
	 *
	 * // 移动端 绘制临时标注圆
	 * async function test(){
		const getPoint = new MxCADUiPrPoint();
		getPoint.setMessage("\n指定一点:");
		getPoint.setOffsetInputPostion(true);
		getPoint.clearLastInputPoint();
		let pt1 = (await getPoint.go());
		if (!pt1) return;

		let mxdraw = MxFun.getCurrentDraw();

		mxdraw.getTempMarkDraw().drawCircleMark(pt1.toVector3(), mxdraw.viewCoordLong2Cad(50), 0xFF0000);
		mxdraw.updateDisplay();
	 * }
	 * ```
	 */
	setOffsetInputPostion(isOffset: boolean): void;
	/** 设置是否禁用动态跟踪
	 * @param isDisable 是否禁用
	 *  */
	setDisableDynamicTrace(isDisable: boolean): void;
	/** 是否禁用动态跟踪
	 * */
	isDisableDynamicTrace(): boolean;
	/** 设置是否禁用极轴跟踪
	 * @param isDisable 是否禁用
	 * */
	setDisablePolarAxisTrace(isDisable: boolean): void;
	/** 是否禁用极轴跟踪
	 * */
	isDisablePolarAxisTrace(): boolean;
	/** 设置是否禁用格网追踪
	 * @param isDisable 是否禁用
	 * */
	setDisableGridTrace(isDisable: boolean): void;
	/** 是否禁用格网追踪
	 * */
	isDisableGridTrace(): boolean;
	/** 设置是否禁用正射追踪
	 * @param isDisable 是否禁用
	 * */
	setDisableOrthoTrace(isDisable: boolean): void;
	/** 是否禁用正射追踪
	 * */
	isDisableOrthoTrace(): boolean;
	/** 禁用所有跟踪
	 * @param isDisable 是否禁用
	*/
	disableAllTrace(isDisable?: boolean): void;
	/**
	 * 返回输入控制设置
	 */
	userInputControls(): number;
	/**
	* 设置输入控制设置
	* @example
	* ```ts
	* // 以 MxCADUiPrInt 类示例
	  import { MxCADUiPrInt } from 'mxcad';
	  import { UserInputControls } from "mxdraw"
	*
	  let getInt = new MxCADUiPrInt();
	  getInt.setMessage("输入整数:");
	  getInt.setUserInputControls(UserInputControls.kNoZeroResponseAccepted);
	  let iRowNum = await getInt.go();
	  if (iRowNum == null) return;
	* ```
	*/
	setUserInputControls(contros: number): void;
	/**
	* 停止当前动态拖动
	* @returns void
	*/
	abort(cause?: DetailedResult): void;
}
/**
 * MxCADUiPrPoint 是一个用于在 CAD 图纸中交互式获取点坐标的提示类。
 *
 * @description
 * 该类用于在用户界面中让用户在图纸上点击指定位置，并返回对应的三维点坐标。
 * 常用于设置插入点、拾取基点、标注起点、对象参考点等交互式操作场景。
 * 使用方法：
 * 1. new MxCADUiPrPoint() 创建交互器；
 * 2. 调用 setMessage() 设置提示文本；
 * 3. 通过 go() 等待用户在图纸上选择点；
 * 4. 获取返回值后，用 value() / basePt() / getDocValue() 继续进行后续计算或绘制。
 *
 * @example
 * ```ts
 * import { MxCADUiPrPoint } from "mxcad";
 *
 * const getPoint = new MxCADUiPrPoint();
 * getPoint.setMessage("请选择一个基点");
 * const point = await getPoint.go();
 * if (!point) return;
 *
 * console.log("选中的点：", point.x, point.y, point.z);
 * ```
 */
export declare class MxCADUiPrPoint extends MxCADUiPrBase {
	/**
	 * 构造函数
	 */
	constructor();
	/**
	 * 运行go方法, 将返回用户交互的Promise任务
	 * @returns 返回一个promise对象，包含了用户点击页面得到的坐标点
	 * @description
	 * 当鼠标点击画布后 Promise完成, 得到其点击的坐标点
	 * 其他交互操作方式将返回null 如按下Esc取消键或在交互中输入对应的关键词
	 */
	go(): Promise<McGePoint3d | null>;
	/**
	 * 得以获取的点
	 * @returns 点坐标
	 * @example
	 * ```ts
	 * import { MxCADUiPrPoint } from "mxcad"
	 *
	 * const getPoint = new MxCADUiPrPoint();
	 * await getPoint.go();
	 * const pt = getPoint.value();
	 * console.log(pt)
	 * ```
	 */
	value(): McGePoint3d;
	/**
	 * 得到文档坐标.
	 * @returns 点对象 MdGePoint3d
	 * @example
	 * ```ts
	 * import { MxCADUiPrPoint } from "mxcad"
	 *
	 * const getPoint = new MxCADUiPrPoint();
	 * await getPoint.go();
	 * const pt = getPoint.getDocValue();
	 * console.log(pt)
	 * ```
	 */
	getDocValue(): McGePoint3d;
	/**
	 * 得到动态拖动的基点
	 * @returns 基点 McGePoint3d
	 * @example
	 * ```ts
	 * import { MxCADUiPrPoint } from "mxcad"
	 *
	 * const getPoint = new MxCADUiPrPoint();
	 * getPoint.setBasePt(new McGePoint3d(0,0,0));
	 * await getPoint.go();
	 * console.log(getPoint.basePt())//(0,0,0)
	 * ```
	 */
	basePt(): McGePoint3d;
	/**
	 * 设置动态拖动的基点
	 * @param basePt 基点 McGePoint3d
	 */
	setBasePt(basePt: McGePoint3d): void;
	/**
	 * 设置动态拖动的基点用于动态绘制。
	 * @param useIt 是否设置,setBasePt会自设置true.
	 * @returns void
	 */
	setUseBasePt(useIt: boolean): void;
}
/**
 * MxCADUiPrPointTransform 是在 MxCADUiPrPoint 基础上增加坐标系变换能力的交互取点类。
 *
 * @description
 * 该类适用于在特定坐标系中进行交互取点，例如局部坐标系、工作坐标系或自定义视图坐标系。
 * 它可以在用户选点时自动应用矩阵转换，便于在变换后的空间中完成交互输入。
 * 使用方法：
 * 1. new MxCADUiPrPointTransform(mat) 创建带坐标变换的取点器；
 * 2. 传入用于映射的 McGeMatrix3d；
 * 3. 调用 go() 获取用户点击点；
 * 4. 取回的点会按矩阵约定转换到目标坐标系中。
 *
 * @example
 * ```ts
	import { MxCpp, McGePoint3d, MxCADUiPrPointTransform, McGeMatrix3d, McGeVector3d, McDbPolyline } from "mxcad";

	async function Mx_Test_Rect() {
	const mxcad = MxCpp.getCurrentMxCAD();
	let mat = new McGeMatrix3d;
	mat.setToRotation(-mxcad.mxdraw.getViewAngle(), McGeVector3d.kZAxis, McGePoint3d.kOrigin);

	const getPoint = new MxCADUiPrPointTransform(mat);
	getPoint.clearLastInputPoint();
	getPoint.setDisableDynInput(true);
	getPoint.setMessage("请选择第一个点");
	const pt1 = await getPoint.go();
	if (!pt1) return;

	const getNextPt = new MxCADUiPrPointTransform(mat);
	getNextPt.setMessage("请选择第二个点");
	getNextPt.setUserDraw((pt2, pWorldDraw) => {
		let pl = new McDbPolyline();
		pl.addVertexAt(pt1);
		pl.addVertexAt(new McGePoint3d(pt1.x, pt2.y, pt1.z));
		pl.addVertexAt(pt2);
		pl.addVertexAt(new McGePoint3d(pt2.x, pt1.y, pt1.z));
		pl.isClosed = true;
		pWorldDraw.drawMcDbEntity(pl);
	});

	if (!await getNextPt.go()) return;

	getNextPt.drawReserve();
	}
 * ```
 */
export declare class MxCADUiPrPointTransform extends MxCADUiPrPoint {
	mat: McGeMatrix3d;
	rmat: McGeMatrix3d;
	mat_three: THREE.Matrix4;
	rmat_three: THREE.Matrix4;
	constructor(mat: McGeMatrix3d);
	/**
	* 运行go方法, 将返回用户交互的Promise任务
	* @returns 返回一个promise对象，包含了用户点击页面得到的坐标点
	*/
	go(): Promise<McGePoint3d | null>;
	/**
	 * 得以获取的点
	 * @returns 点坐标
	 */
	value(retcad_val?: boolean): McGePoint3d;
	/**
	 * 得到动态拖动的基点
	 * @returns 基点 McGePoint3d
	 */
	basePt(retcad_val?: boolean): McGePoint3d;
	/**
	 * 设置动态拖动的基点
	 * @param basePt 基点 McGePoint3d
	 */
	setBasePt(basePt: McGePoint3d, cad_val?: boolean): void;
	/**
	* 设置动态绘制
	* @param basePt 基点 McGePoint3d
	*/
	setUserDraw(pDraw: ((currentPoint: McGePoint3d, pWorldDraw: McEdGetPointWorldDrawObject) => void)): void;
}
/**
 * 交互式距离输入类，用于在两点之间获取距离值。
 * @description
 * `MxCADUiPrDist` 是基于 `MxCADUiPrBase` 的交互控件，用于提示用户通过两点输入来确定一个距离值。
 * 它支持设置提示信息、动态拖动基点、动态绘制回调以及获取最终距离值和详细退出原因。
 * 常用于标注、测量或需要用户确定长度的交互场景。
 * 使用方法:
 * 1. 创建 `MxCADUiPrDist` 实例并通过 `setMessage` 设置提示信息；
 * 2. （可选）使用 `setBasePt` / `setUserDraw` 设置动态拖动基点或动态绘制效果以增强用户体验；
 * 3. 调用 `go()` 等待用户输入，随后通过 `value()` 获取距离结果并通过 `getDetailedResult()` 判断退出原因。
 * @example
 * ```ts
 * import { MxCADUiPrDist } from 'mxcad';
 *
 * async function measure() {
 *   const getDist = new MxCADUiPrDist();
 *   getDist.setMessage('\n指定第一点和第二点以确定距离:');
 *   // 可选：设置动态绘制
 *   getDist.setUserDraw((pt, worldDraw) => {
 *     worldDraw.setColor(0x00ff00);
 *     // 这里假设绘制一个临时标记
 *   });
 *
 *   const val = await getDist.go();
 *   if (val == null) return; // 用户取消或其他原因
 *   const dist = getDist.value();
 *   console.log('测得距离:', dist);
 * }
 * ```
 */
export declare class MxCADUiPrDist extends MxCADUiPrBase {
	/**
	 * 构造函数
	 * */
	constructor();
	/**
	 * 得以获取的距离
	 * @returns 返回距离值
	 * @example
	 * ```ts
	 * import { MxCADUiPrDist } from 'mxcad'
	 *
	 * const getDist = new MxCADUiPrDist();
	 * const val = await getDist.go();
	 * if(!val) return;
	 * const dist = getDist.value();
	 * console.log(dist)
	 * ```
	 */
	value(): number;
	/**
	 * 得到动态拖动的基点
	 * @returns 基点 McGePoint3d
	 */
	basePt(): McGePoint3d;
	/**
	 * 设置动态拖动的基点
	 * @param basePt 基点 McGePoint3d
	 */
	setBasePt(basePt: McGePoint3d): void;
	/**
	 * 设置使用动态拖动的基点
	 * @param useIt 是否启用基点进行动态跟随/动态绘制 默认为false
	 * @returns void
	 */
	setUseBasePt(useIt: boolean): void;
	/**
	 * 开始动态拖动
	 * @returns 返回一个promise对象，包含了用户设置的距离
	 */
	go(): Promise<number | null>;
}
/**
 * MxCADUiPrAngle 是一个用于交互式输入角度值的提示类。
 *
 * @description
 * 该类用于让用户在图纸中根据两条参考方向或指定位置确定角度，并返回角度数值。
 * 在 CAD 命令中，它常用于旋转角、夹角、方向角和参数设置等交互场景。
 * 使用方法：
 * 1. new MxCADUiPrAngle() 创建角度输入器；
 * 2. 调用 setMessage() 设置提示信息；
 * 3. 通过 go() 让用户指定角度；
 * 4. 获取返回值后，通过 value() 使用角度结果进行后续计算。
 *
 * @example
 * ```ts
 * import { MxCADUiPrAngle } from "mxcad";
 *
 * const getAngle = new MxCADUiPrAngle();
 * getAngle.setMessage("请选择参考方向并输入角度");
 * const angle = await getAngle.go();
 * if (angle == null) return;
 *
 * console.log("角度值：", angle);
 * ```
 */
export declare class MxCADUiPrAngle extends MxCADUiPrBase {
	/**
	 * 构造函数
	 */
	constructor();
	/**
	 * 得到获取的距离
	 * @example
	 * ```ts
	 * import { MxCADUiPrAngle } from 'mxcad'
	 *
	 * const getAngle = new MxCADUiPrAngle();
	 * const val = await getAngle.go();
	 * const angle = getAngle.value();
	 * console.log(angle);
	 * ```
	 */
	value(): number;
	/**
	 * 得到动态拖动的基点
	 * @returns 基点 McGePoint3d
	 */
	basePt(): McGePoint3d;
	/**
	 * 设置动态拖动的基点
	 * @param basePt 基点 McGePoint3d
	 */
	setBasePt(basePt: McGePoint3d): void;
	/**
	 * 设置使用动态拖动的基点
	 * @param useIt 是否设置 默认为false
	 * @returns void
	 */
	setUseBasePt(useIt: boolean): void;
	/**
	 * 开始动态拖动
	 * @returns 返回一个promise对象，包含了用户设置的角度
	 */
	go(): Promise<number | null>;
}
/**
 * MxCADUiPrInt 是一个用于交互式输入整数的提示类。
 *
 * @description
 * 该类用于让用户在命令流程中输入整数参数，例如层编号、数量、重复次数、索引值等。
 * 常用于命令提示和交互式参数录入，适合需要用户确认数值参数的场景。
 * 使用方法：
 * 1. new MxCADUiPrInt() 创建整数输入器；
 * 2. 调用 setMessage() 设置提示文本；
 * 3. 通过 go() 等待用户输入整数；
 * 4. 获取返回值后，使用 value() 继续后续逻辑。
 *
 * @example
 * ```ts
 * import { MxCADUiPrInt } from "mxcad";
 *
 * const getInt = new MxCADUiPrInt();
 * getInt.setMessage("请输入循环次数:");
 * const count = await getInt.go();
 * if (count == null) return;
 *
 * console.log("循环次数：", count);
 * ```
 */
export declare class MxCADUiPrInt extends MxCADUiPrBase {
	/**
	 * 构造函数
	 */
	constructor();
	/**
	 * 得以获取的整数
	 * @example
	 * ```ts
	 * import { MxCADUiPrInt } from 'mxcad';
	 *
	 * const getInt = new MxCADUiPrInt();
	 * const val = await getInt.go();
	 * if(!val) return;
	 * const int = getInt.value();
	 * ```
	 */
	value(): number;
	/**
	 * 开始动态拖动
	 * @returns 返回一个promise对象，包含了用户输入的整数
	 */
	go(): Promise<number | null>;
}
/**
 * MxCADUiPrKeyWord 是一个用于交互式输入关键词选项的提示类。
 *
 * @description
 * 该类用于让用户从一组关键字中选择一个选项，例如“新增/修改/删除”、“自动/手动”、“是/否”等。
 * 常用于命令分支选择和交互式参数确认，适合简化复杂命令的用户决策流程。
 * 使用方法：
 * 1. new MxCADUiPrKeyWord() 创建关键字输入器；
 * 2. 调用 setKeyWords() 设置关键词列表；
 * 3. 调用 go() 等待用户选择；
 * 4. 获取返回值后使用 value() 或 keyWordPicked() 继续下一步逻辑。
 *
 * @example
 * ```ts
 * import { MxCADUiPrKeyWord } from "mxcad";
 *
 * const getKey = new MxCADUiPrKeyWord();
 * getKey.setMessage("请选择操作方式");
 * getKey.setKeyWords("[手动(M)/自动(A)]");
 * const key = await getKey.go();
 * if (!key) return;
 *
 * console.log("用户选择：", key);
 * ```
 */
export declare class MxCADUiPrKeyWord extends MxCADUiPrBase {
	/**
	 * 构造函数
	 */
	constructor();
	/**
	 * 开始动态拖动
	 * @returns 返回一个promise对象，包含了用户输入的关键字
	 * @example
	 * ```ts
	 * import { MxCADUiPrKeyWord } from 'mxcad'
	 *
	 * const getType = new MxCADUiPrKeyWord();
	 * getType.setMessage('选择连接方式');
	 * getType.setKeyWords('[手动逐个连线(H)/自动批量连线(A)]')
	 * const type = await getType.go();
	 * if (!type) return;
	 * ```
	 */
	go(): Promise<string | null>;
}
/**
 * MxCADUiPrString 是一个用于交互式输入字符串的提示类。
 *
 * @description
 * 该类用于让用户在 CAD 命令中输入文本参数，例如图层名、注释文本、块名、文件名等。
 * 它适用于需要动态获取字符串参数的交互式编辑流程。
 * 使用方法：
 * 1. new MxCADUiPrString() 创建字符串输入器；
 * 2. 调用 setMessage() 设置提示信息；
 * 3. 调用 go() 等待用户输入；
 * 4. 使用 value() 获取用户输入的最终字符串。
 *
 * @example
 * ```ts
 * import { MxCADUiPrString } from "mxcad";
 *
 * const getStr = new MxCADUiPrString();
 * getStr.setMessage("请输入图层名称");
 * const name = await getStr.go();
 * if (!name) return;
 *
 * console.log("用户输入：", name);
 * ```
 */
export declare class MxCADUiPrString extends MxCADUiPrBase {
	/**
	 * 构造函数
	 */
	constructor();
	/**
	 * 获取用户输入的字符串
	 * @example
	 * ```ts
	 * import { MxCADUiPrString } from 'mxcad';
	 *
	 * const getStr = new MxCADUiPrString();
	 * const val = await getStr.go();
	 * if(!val) return;
	 * const string = getStr.value();
	 * console.log(string)
	 * ```
	 */
	value(): string;
	/**
	 * 开始动态拖动
	 * @returns 返回一个promise对象，包含了用户输入的字符串
	 */
	go(): Promise<string | null>;
}
/**
 * MxCADUiPrEntity 是一个用于交互式选择实体对象的提示类。
 *
 * @description
 * 该类用于让用户在图纸上点击某个实体，并返回对应的对象 ID。随后可通过 McObjectId.getMcDbEntity() 获取实体实例，进行编辑、删除、属性读取等后续操作。
 * 它适用于需要“用户选择某个对象后继续操作”的场景，如编辑对象、附加属性、批量修改等。
 * 使用方法：
 * 1. new MxCADUiPrEntity() 创建实体选择器；
 * 2. 调用 setMessage() 设置提示信息，并可 setFilter() 限制可选对象类型；
 * 3. 调用 go() 等待用户选择对象；
 * 4. 获取 McObjectId 后，使用 getMcDbEntity() 读取对象并进行下一步处理。
 *
 * @example
 * ```ts
 * import { MxCADUiPrEntity } from "mxcad";
 *
 * const getEnt = new MxCADUiPrEntity();
 * getEnt.setMessage("请选择目标对象");
 * const entId = await getEnt.go();
 * if (!entId || !entId.id) return;
 *
 * const ent = entId.getMcDbEntity();
 * if (ent) console.log("当前对象类型：", ent.objectName);
 * ```
 */
export declare class MxCADUiPrEntity extends MxCADUiPrBase {
	private filter?;
	private id;
	/**
	 * 构造函数
	 */
	constructor(isDisableAllTrace?: boolean);
	/**
	 * 设置或获取筛选条件
	 * @param filter 筛选条件
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity, MxCADResbuf } from "mxcad";
	 *
	 * const filter = new MxCADResbuf();
	 * filter.AddMcDbEntityTypes("LINE");
	 * const getEnt = new MxCADUiPrEntity();
	 * getEnt.setFilter(filter);
	 * const entId = await getEnt.go();
	 * if (!entId || !entId.id) return;
	 *
	 * const ent = entId.getMcDbEntity();
	 * if (ent) console.log("当前对象类型：", ent.objectName);
	 * ```
	 */
	setFilter(filter: MxCADResbuf): void;
	/**
	 * 获取 MxCADUiPrEntity 设置的筛选条件详情
	 * @returns 筛选条件对象
	 */
	getFilter(): MxCADResbuf | undefined;
	/**
	 * 开始动态选择
	 * @returns 返回一个promise对象，包含了用户选择的对象
	 */
	go(): Promise<McObjectId>;
	/**
	 * 得到获取对象时的输入点
	 * @return 获取对象时的输入点
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity } from 'mxcad'
	 *
	 * const getEnt = new MxCADUiPrEntity();
	 * const entId = await getEnt.go();
	 * if (!entId.id) return;
	 * const point = getEnt.pickPoint();
	 * console.log(point)
	 * ```
	 */
	pickPoint(): McGePoint3d;
	/**
	 * 得以获取对象时的id
	 * @returns 返回对象id
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity } from 'mxcad'
	 *
	 * const getEnt = new MxCADUiPrEntity();
	 * const entId = await getEnt.go();
	 * if (!entId.id) return;
	 * const id = getEnt.value();
	 * ```
	 */
	value(): McObjectId;
	/**
	 * 得以获取对象时的输入点的CAD图纸坐标.
	 * @returns 点对象 MdGePoint3d
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity } from 'mxcad'
	 *
	 * const getEnt = new MxCADUiPrEntity();
	 * const entId = await getEnt.go();
	 * if (!entId.id) return;
	 * const point = getEnt.getDocPickPoint();
	 * ```
	 */
	getDocPickPoint(): McGePoint3d;
}
/**
 * McDbEntity 是所有数据库图形实体对象的基类，封装了实体通用的属性和操作。
 *
 * @description
 * 该类用于表示 CAD 中具有图形显示能力的数据库对象。
 *
 * 它提供通用的颜色、图层、线型、线宽、文字样式、可见性和几何包围盒等属性访问与操作。通过它可以实现实体的创建、变换、打碎、扩展数据管理等基础功能。
 *
 * 使用方法总结：
 * 1. 先获取实体对象。
 * 2. 再通过属性和方法读取其图层、颜色、线型、几何包围盒等显示与几何信息。
 * 3. 最后根据业务需要执行变换、打碎或扩展数据处理。
 *
 * @example
 * ```ts
 * import { MxCADUiPrEntity, McDbEntity } from "mxcad";
 *
 * //设置扩展数据
 * let selEntity = new MxCADUiPrEntity();
 * selEntity.setMessage("选择对象");
 * let id = await selEntity.go();
 * if (!id.isValid()) return;
 * let ent:McDbEntity = id.getMcDbEntity();
 * if (ent === null) return;
 * const color = ent.tureColor;
 * const layer = ent.layer;
 * let retExplode: MxCADResbuf = ent.explode();
 * ```
 *
 */
export declare class McDbEntity extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 打碎对象，返回打后对象数据链表
	 * @return resbuf 数据
	 * @example
	 * ```ts
	 * import { McDbEntity, MxCADResbuf } from "mxcad";
	 * // 获取目标对象
	 * let getEnt = new MxCADUiPrEntity();
	 * getEnt.setMessage("选择打碎对象:");
	 * let id = await getEnt.go();
	 * let ent:McDbEntity = id.getMcDbEntity();
	 * if (ent === null) return;
	 * // 打碎对象
	 *       let retExplode: MxCADResbuf = ent.explode();
	 *       if (retExplode.GetCount() == 0) return;
	 *       let iExplodeConut = retExplode.GetCount();
	 *       for (let j = 0; j < iExplodeConut; j++) {
	 *           let tmpobj = retExplode.AtObject(j).val;
	 *           if(tmpobj instanceof McDbEntity ){
	 *               mxcad.drawEntity(tmpobj);
	 *           }
	 *       }
	 * ```
	 */
	explode(): MxCADResbuf;
	/**
	 * 得到对象颜色
	 */
	get trueColor(): McCmColor;
	/**
	 * 设置对象颜色
	 */
	set trueColor(val: McCmColor);
	/**
	 * 得到对象颜色索引
	 */
	get colorIndex(): number;
	/**
	 * 设置对象颜色索引
	 * @param val 颜色索引（ColorIndexType）
	 */
	set colorIndex(val: number);
	/**
	 * 得到对象图层名
	 */
	get layer(): string;
	/**
	 * 设置对象图层名
	 * @param val 图层名
	 */
	set layer(val: string);
	/**
	* 得到对象线型名
	*/
	get linetype(): string;
	/**
	 * 设置对象线型名
	 * @param  val 线型名
	 */
	set linetype(val: string);
	/**
	 * 得到对象厚度
	 */
	get thickness(): number;
	/**
	 * 设置对象厚度
	*/
	set thickness(val: number);
	/**
	 * 得到对象线型比例
	 */
	get linetypeScale(): number;
	/**
	 * 设置对象线型比例
	 * @param val 线型比例
	 */
	set linetypeScale(val: number);
	/**
	 * 对象是否可见
	 */
	get visible(): boolean;
	/**
	 * 设置是否可见
	 * @param val 布尔值
	 */
	set visible(val: boolean);
	/**
	 * 得到对象线重
	 */
	get lineweight(): number;
	/**
	 * 设置对象线重
	 * @param val 线重
	 */
	set lineweight(val: number);
	/**
	 * 得到对象文字样式
	 */
	get textStyle(): string;
	/**
	 * 设置对象文字样式
	 * @param val 文字样式名
	 */
	set textStyle(val: string);
	/**
	 * 设置对象是否高亮
	 * @param isHighlight 是否高亮
	 */
	highlight(isHighlight: boolean): void;
	/**
	 * 移动对象
	 * @param fromPoint 移动开始点
	 * @param toPoint 移动结束点
	 */
	move(fromPoint: McGePoint3d, toPoint: McGePoint3d): boolean;
	/**
	 * 旋转对象
	 * @param basePoint 旋转基点
	 * @param dRotationAngle 旋转角度
	 */
	rotate(basePoint: McGePoint3d, dRotationAngle: number): boolean;
	/**
	 * 镜向对象
	 * @param point1 镜像基点
	 */
	mirror(point1: McGePoint3d, point2: McGePoint3d): boolean;
	/**
	 * 缩放对象
	 * @param basePoint 缩放基点
	 * @param dScaleFactor 缩放因子（<1 缩小； >1 放大）
	 */
	scaleEntity(basePoint: McGePoint3d, dScaleFactor: number): boolean;
	/**
	 * 变换对象
	 * @param transformationMatrix 变换矩阵
	 */
	transformBy(transformationMatrix: McGeMatrix3d): boolean;
	/**
	 * 得到对象的最小外包
	 * @param minPt 实例对象的最小点
	 * @param maxPt 实例对象的最大点
	 * @param ret 是否获取成功
	 */
	getBoundingBox(): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
		ret: boolean;
	};
	/**
   * 得到对象的扩展数据
   * @param appName 扩展数据名
   */
	getxData(appName?: string): MxCADResbuf;
	/**
	 * 设置对象的扩展数据
	 * @param xdata 扩展数据链表
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity, McDbEntity } from "mxcad";
	 *
	 * //设置扩展数据
	 * let selEntity = new MxCADUiPrEntity();
	 * selEntity.setMessage("选择对象");
	 * let id = await selEntity.go();
	 * if (!id.isValid()) return;
	 * let ent:McDbEntity = id.getMcDbEntity();
	 * if (ent === null) return;
	 * ent.setxData(new MxCADResbuf([{type:DxfCode.kExDataName,val:"DataName"},{type:DxfCode.kString,val:"yyyyy"}]));
	 * ```
	 */
	setxData(xdata: MxCADResbuf): boolean;
	/**
	 * 获取与特定实体关联的 XData 信息，并以字符串形式返回
	 * @param appName 扩展数据名称
	 * @returns { object } val XData信息 | ret 是否返回成功
	 */
	getxDataString(appName: string): {
		val: string;
		ret: boolean;
	};
	/**
	 * 设置与特定实体关联的 XData 信息，并以字符串形式设置
	 * @param appName 扩展数据名称
	 * @param val 字符串值
	 * @returns 是否设置成功
	 */
	setxDataString(appName: string, val: string): boolean;
	/**
	 * 获取实体的指定 XData 类型中的 double 值
	 * @param appName 扩展数据名称
	 * @returns double 值
	 */
	getxDataDouble(appName: string): {
		val: number;
		ret: boolean;
	};
	/**
	 * 设置实体的指定 XData 类型中的 double 值
	 * @param appName 扩展数据名称
	 * @param val double 值
	 * @returns 布尔值
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity, McDbEntity } from "mxcad";
	 * let selEntity = new MxCADUiPrEntity();
	 * selEntity.setMessage("选择对象");
	 * let id = await selEntity.go();
	 * if (!id.isValid()) return;
	 * let ent:McDbEntity = id.getMcDbEntity();
	 * if (ent === null) return;
	 * const res = ent.setxDataDouble("DataName", 0);
	 * if(res){
	 *   //设置成功
	 * }else{
	 *   //设置失败
	 * }
	 * ```
	 */
	setxDataDouble(appName: string, val: number): boolean;
	/**
	 * 获取实体的指定 XData 类型中的 long（整数）值
	 * @param appName 扩展数据名称
	 * @returns long 值
	 */
	getxDataLong(appName: string): {
		val: number;
		ret: boolean;
	};
	/**
	 * 设置实体的指定 XData 类型中的 long（整数）值
	 * @param appName 扩展数据名称
	 * @param val long 值
	 * @returns long 值
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity, McDbEntity } from "mxcad";
	 *
	 * let selEntity = new MxCADUiPrEntity();
	 * selEntity.setMessage("选择对象");
	 * let id = await selEntity.go();
	 * if (!id.isValid()) return;
	 * let ent:McDbEntity = id.getMcDbEntity();
	 * if (ent === null) return;
	 * const res = ent.setxDataLong("DataName", 123456);
	 * if(res){
	 *   //设置成功
	 * }else{
	 *   //设置失败
	 * }
	 * ```
	 */
	setxDataLong(appName: string, val: number): boolean;
	/**
	 * 获取实体的指定 XData 类型中的点对象
	 * @param appName 扩展数据名称
	 * @return 获取结果及三维点对象
	 */
	getxDataPoint(appName: string): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 设置实体的指定 XData 类型中的点对象
	 * @param appName 扩展数据名称
	 * @param val 点对象
	 * @return 获取结果及三维点对象
	 */
	setxDataPoint(appName: string, val: McGePoint3d): boolean;
	/**
	 * 删除实体指定应用程序名称相关的数据
	 * @param appName 扩展数据名称
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity, McDbEntity } from "mxcad";
	 *
	 * let selEntity = new MxCADUiPrEntity();
	 * selEntity.setMessage("选择对象");
	 * let id = await selEntity.go();
	 * if (!id.isValid()) return;
	 * let ent:McDbEntity = id.getMcDbEntity();
	 * if (ent === null) return;
	 * const res = ent.deleteXData("DataName");
	 * if(res){
	 *   //删除成功
	 * }else
	 *   //删除失败
	 * }
	 * ```
	 */
	deleteXData(appName: string): boolean;
	/**
	 * 获取实体中包含的所有 XData 记录的应用程序名（AppName）
	 */
	getAllAppName(): McGeStringArray;
	/**
	 * 获取图层ID对象
	 */
	get layerId(): McObjectId;
	/**
	 * 设置图层Id对象
	 */
	set layerId(id: McObjectId);
	/**
	 * 获取实体对象线型ID
	 */
	get linetypeId(): McObjectId;
	/**
	 * 设置实体对象线型ID
	 */
	set linetypeId(id: McObjectId);
	/**
	 * 获取实体文字样式
	 */
	get textStyleId(): McObjectId;
	/**
	 * 设置实体的文字样式
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity, McDbEntity } from "mxcad";
	 *
	 * let selEntity = new MxCADUiPrEntity();
	 * selEntity.setMessage("选择对象");
	 * let id = await selEntity.go();
	 * if (!id.isValid()) return;
	 * let ent:McDbEntity = id.getMcDbEntity();
	 * if (ent === null) return;
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * const textStyleId = mxcad.addTextStyle("MyLineTypeTextStyle", "txt.shx", "hztxt.shx", 1);
	 * ent.textStyleId = textStyleId;
	 * ```
	 */
	set textStyleId(id: McObjectId);
	/** 与其他实体相交, 得到交点
	* @param intersectObject 需要相交的是实体对象
	* @param exOption 相交的选项
	* @returns 得到所有交点
	* @example
	* ```ts
	* import { McDbLine, McDb } from 'mxcad'
	* const line1 = new McDbLine(new McGePoint3d(0,0,0), new McGePoint3d(20,1,0));
	* const line2 = new McDbLine(new McGePoint3d(10,10,0), new McGePoint3d(11,1,0));
	* const ptArr = line1.IntersectWith(line2, McDb.Intersect.kExtendBoth)
	* ```
	*  */
	IntersectWith(intersectObject: McDbEntity, exOption: McDb.Intersect): McGePoint3dArray;
	/**
	 * 计算面积
	 * @returns { object } val 面积值 | ret 是否获取成功
	 * @example
	 * ```ts
	 * import { McGePoint3d, McDbCircle } from "mxcad"
	 *
	 * const circle = new McDbCircle(0,0,0, 20);
	 * const area = circle.getArea();
	 * console.log("圆面积：", area)
	 * ```
	 */
	getArea(): {
		val: number;
		ret: boolean;
	};
	/**
	 * 禁用对象的自动更新显示.
	 * @param isDisable 是否禁用对象自动更新显示
	 */
	disableDisplay(isDisable: boolean): void;
	/**
	 * 显示调用对象更新显示.
	 */
	updateDisplay(): void;
	/**
	 * 同步实体的数据。这个方法可能是在修改了实体的属性或者附加了新的数据之后调用的，以确保所有的改变都被正确地保存到实体的数据库记录中。
	 * @param _toCpp 是否同步数据
	 */
	syncData(_toCpp?: boolean): boolean;
	/**
	 * 对象的显示顺序
	 */
	get drawOrder(): number;
	/**
	* 对象的显示顺序
	* @param order 顺序值
	* @example
	* ```ts
	* import { MxCpp, MxCADSelectionSet } from "mxcad";
	*
	* let ss = new MxCADSelectionSet();
	* if (!await ss.userSelect("\n选择对象")) return;
	* //得到当前图上对象的最大，小最显示顺序.
	* let minmaxOrder = MxCpp.getCurrentDatabase().currentSpace.getMinMaxDrawOrder();
	* // 把对象放到最上面。
	* let lOrder = minmaxOrder.maxDrawOrder + 1;
	* ss.forEach((id) => {
	*   let ent = id.getMcDbEntity();
	*   if (ent) {
	*     ent.drawOrder = lOrder;
	*   }
	* })
	* ```
	*/
	set drawOrder(order: number);
	/**
	 * 返回对象的normal
	 */
	get normal(): McGeVector3d;
	/**
	* 设置对象的normal
	*/
	set normal(val: McGeVector3d);
}
/**
 * McDbCurve 是所有曲线类实体的基类，用于管理曲线型几何对象的公共行为。
 *
 * @description
 * 该类用于表示 CAD 中的曲线类实体，适合承载直线、圆弧、椭圆等曲线相关对象的公共属性和操作。
 *
 * 通过它可以统一处理曲线对象的长度、采样点、变换和包围盒等通用能力。
 *
 * 使用方法总结：
 * 1. 先通过 McDbLine、McDbArc 等子类实例化具体曲线对象。
 * 2. 再设置其起点、终点、半径、角度或控制点等几何参数。
 * 3. 最后调用绘制或插入接口将其显示到当前图纸中。
 *
 * @example
 * ```ts
 * // 下面代码演示了，选择一个曲线，然后选择其它曲线，计算曲线与这个曲线的交点，然后在交点处打断曲线。
	import { MxCADUiPrEntity, MxCADResbuf, MxCpp, MxCADUtility, McDbCurve } from "mxcad";

	async function Mx_IntersectBreak() {
		// 选择参考曲线
		let eventObj = new MxCADUiPrEntity();
		eventObj.setMessage("请选择参考曲线");
		let eventObj_id = await eventObj.go();
		let event = await eventObj_id.getMcDbEntity()//获取实例对象
		if (event === null) return;
		const mxcad = MxCpp.App.getCurrentMxCAD();
		let curve = event.clone();// 克隆曲线
		let filter = new MxCADResbuf();
		//设置过滤器 选中圆类、圆弧类、直线类、多段线类、椭圆类
		filter.AddMcDbEntityTypes("CIRCLE,ARC,LINE,LWPOLYLINE,ELLIPSE");
		let aryId = await MxCADUtility.userSelect("选择打断对象", filter);//选中对象的id
		if (aryId.length == 0) return
		// 遍历选中的曲线对象
		aryId.forEach(async (id) => {
			if (id.id !== eventObj_id.id) {
				let breakEvent: McDbCurve = (await id.getMcDbEntity()) as McDbCurve;// 获取打断曲线的实例
				let breakArr = breakEvent.IntersectWith(curve as McDbEntity, McDb.Intersect.kOnBothOperands);//与实体相交的点集合
				if (breakArr.length() != 0) {
					//有交点的对象
					let arr: McGePoint3d[] = [];//交点数组
					breakArr.forEach((item: McGePoint3d) => {
						arr.push(item)
					})
					let breakPoint: McGePoint3d[] = [];
					arr.forEach(pt => {
						let closePoint = breakEvent.getClosestPointTo(pt, false);//曲线上离鼠标位置最近的点
						if (!closePoint.ret) return;
						let vec = breakEvent.getFirstDeriv(closePoint.val);//断点所在位置的向量
						if (!vec.ret) return;
						vec.val.normalize().mult(MxFun.viewCoordLong2Cad(10));//断开的距离
						let pt1 = closePoint.val.clone();
						pt1.addvec(vec.val);
						let pt2 = closePoint.val.clone();
						pt2.subvec(vec.val);
						breakPoint.push(pt1);
						breakPoint.push(pt2);
					});
					let breakcurve = breakEvent.splitCurves(breakPoint);// 根据端点截取曲线
					if (breakcurve.empty()) {
						breakEvent.highlight(false);
						return;
					}
					// 重绘打断后的曲线
					breakcurve.forEach((obj: McDbObject, index: number) => {
						if (index % 2 == 0) mxcad.drawEntity(obj as McDbEntity);
					});
					breakEvent.erase() // 删除原曲线
				}
			}
		})
	}
 * ```
 */
export declare class McDbCurve extends McDbEntity {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取起始参数。
	 * @returns 起始参数及执行结果。
	 */
	getStartParam(): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取结束参数。
	 * @returns 结束参数及执行结果。
	 */
	getEndParam(): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取参数位置上的距离。
	 * @param param 参数位置。
	 * @returns 距离及执行结果。
	 */
	getDistAtParam(param: number): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取距离位置上的参数。
	 * @param dist 距离位置。
	 * @returns 参数及执行结果。
	 */
	getParamAtDist(dist: number): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取曲线上点的距离位置。
	 * @param pt 距离位置。
	 * @returns 点及执行结果。
	 * @example
	 * ```ts
	 * import { McGePoint3d, McDbLine } from "mxcad"
	 *
	 * const pt1 = new McGePoint3d(0,0,0);
	 * const pt2 = new McGePoint3d(20,0,0);
	 * const line = new McDbLine(pt1, pt2)
	 * const res = line.getDistAtPoint(pt2);
	 * if(res.ret){
	 *   const dist = res.val;
	 *   console.log(dist);//20
	 * }
	 * ```
	 */
	getDistAtPoint(pt: McGePoint3d): {
		val: number;
		ret: boolean;
	};
	/**
	 * 获取距离位置上的点。
	 * @param dist 距离位置。
	 * @returns 点及执行结果。
	 * @example
	 * ```ts
	 * import { McGePoint3d, McDbLine } from "mxcad"
	 *
	 * const pt1 = new McGePoint3d(0,0,0);
	 * const pt2 = new McGePoint3d(20,0,0);
	 * const line = new McDbLine(pt1, pt2)
	 * const res = line.getPointAtDist(10);
	 * if(res.ret){
	 *   const point = res.val;
	 *   console.log(point);//(10, 0, 0)
	 * }
	 * ```
	 */
	getPointAtDist(dist: number): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 得到曲线的开始点
	 * @returns 曲线的开始点及执行结果。
	 * @example
	 * ```ts
	 * import { McGePoint3d, McDbLine } from "mxcad"
	 *
	 * const pt1 = new McGePoint3d(0,0,0);
	 * const pt2 = new McGePoint3d(20,0,0);
	 * const line = new McDbLine(pt1, pt2)
	 * const res = line.getStartPoint();
	 * if(res.ret){
	 *   const point = res.val;
	 *   console.log(point);//(0, 0, 0)
	 * }
	 * ```
	 */
	getStartPoint(): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 得到曲线的结束点
	 * @returns 曲线的结束点及执行结果。
	 * @example
	 * ```ts
	 * import { McGePoint3d, McDbLine } from "mxcad"
	 *
	 * const pt1 = new McGePoint3d(0,0,0);
	 * const pt2 = new McGePoint3d(20,0,0);
	 * const line = new McDbLine(pt1, pt2)
	 * const res = line.getEndPoint();
	 * if(res.ret){
	 *   const point = res.val;
	 *   console.log(point);//(20, 0, 0)
	 * }
	 * ```
	 */
	getEndPoint(): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 得到曲线参数所在的点坐标
	 * @param param 曲线参数
	 * @returns 点对象及执行结果。
	 */
	getPointAtParam(param: number): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 得到曲线某点位置的曲线参数
	 * @param pt 曲线上的点
	 * @returns 曲线参数及执行结果。
	 */
	getParamAtPoint(pt: McGePoint3d): {
		val: number;
		ret: boolean;
	};
	/**
	 * 通过曲线参数得到曲线的一阶导数
	 * @param param 曲线参数
	 * @returns 曲线一阶导数及执行结果。
	 */
	getFirstDerivFromParam(param: number): {
		val: McGeVector3d;
		ret: boolean;
	};
	/**
	 * 通过曲线上某点得到曲线的一阶导数
	 * @param pt 曲线上的点
	 * @returns 曲线一阶导数及执行结果。
	 * @example
	 * ```ts
	 * import { McGePoint3d, McDbCircle } from "mxcad"
	 *
	 * const circle = new McDbCircle(0,0,0, 20);
	 * const vec = circle.getFirstDeriv(new McGePoint3d(20,0,0));//目标点切向量
	 * if(vec.ret){
	 *  const val = vec.val;
	 * }
	 * ```
	 */
	getFirstDeriv(pt: McGePoint3d): {
		val: McGeVector3d;
		ret: boolean;
	};
	/**
	 * 得到一个点到曲线的最近点
	 * @param givenPnt 参考点
	 * @param isExtend 是否延展实体
	 * @returns 点对象及执行结果。
	 * @example
	 * ```ts
	 * import { McGePoint3d, McDbCircle, MxCADUiPrPoint, MxCpp } from "mxcad"
	 *
	 * const circle = new McDbCircle(0,0,0, 20);
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * mxcad.drawEntity(circle);
	 *
	 * const getPoint = new MxCADUiPrPoint();
	 * getPoint.setUserDraw((pt,pw)=>{
	 *   //获取pt到circle上最近的点
	 *   const point = circle.getClosestPointTo(pt);
	 *   console.log(point)
	 * })
	 * const point = await getPoint.go();
	 * ```
	 */
	getClosestPointTo(givenPnt: McGePoint3d, isExtend: boolean): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 得到偏移曲线
	 * @param dOffsetDist 偏移距离
	 * @param ptOffsetRef 偏移点
	 * @returns 偏移后的对象数组。
	 * @example
	 * ```ts
	 * import { MxCADUiPrPoint, MxCpp } from 'mxcad'
		let getFristPoint = new MxCADUiPrPoint();
		let offsetDist = 10 ;
		let getEvent = new MxCADUiPrEntity();
		getEvent.setMessage('指定偏移对象');
		let event_id = await getEvent.go();
		if (!event_id) return;
		let event = (await event_id.getMcDbEntity()) as McDbCurve;
		let getoOffPt = new MxCADUiPrPoint();
		getoOffPt.setMessage('指定偏移点');
		let offPt = await getoOffPt.go();
		if (!offPt) return;
		let objArr = event.offsetCurves(offsetDist, offPt);
		if (objArr.length() === 0) return;
		objArr.forEach((obj: McDbObject) => {
			MxCpp.getCurrentCAD().drawEntity(obj as McDbEntity);
		});
	 * ```
	 */
	offsetCurves(dOffsetDist: number, ptOffsetRef: McGePoint3d): McDbObjectArray;
	/**
	 * 打断曲线
	 * @param pts 断点数组
	 * @returns 打断后的曲线数组。
	 */
	splitCurves(pts: McGePoint3d[]): McDbObjectArray;
	/**
	 * 根据曲线参数打断曲线
	 * @param params 曲线参数数组
	 * @returns 打断后的曲线数组。
	 */
	splitCurvesFromParam(params: number[]): McDbObjectArray;
	/**
	 * 把曲线离散成一堆点
	 * @param dApproxEps 采样间隔
	 * @returns resbuf 数据
	 */
	getSamplePoints(dApproxEps?: number): MxCADResbuf;
	/**
	 * 得到曲线长度
	 * @returns
	 * @example
	 * ```ts
	 * import { MxCpp, MxCADResbuf, MxCADUtility, MxCADUiPrPoint} from "mxcad"
	
	 *  const mxcad = MxCpp.App.getCurrentMxCAD();
		let filter = new MxCADResbuf();
		filter.AddMcDbEntityTypes("CIRCLE,ARC,LINE,LWPOLYLINE,ELLIPSE");
		let aryId = await MxCADUtility.userSelect("选择目标曲线", filter);
		if (aryId.length == 0)  return;
		aryId.forEach(async (id) => {
			let event = id.getMcDbEntity() as McDbCurve;
			let length = event.getLength().val;
			console.log(length)
		});
	 * ```
	 */
	getLength(): {
		val: number;
		ret: boolean;
	};
}
/**
 * McDbLine 是直线实体类，用于创建和管理二维或三维直线对象。
 *
 * @description
 * 该类用于在图纸中绘制和编辑直线对象，支持设置起点、终点、颜色、图层和线型等属性。
 *
 * 使用方法总结：
 * 1. 先创建 McDbLine 实例。
 * 2. 再为起点和终点赋值，并设置图层、颜色、线型等显示属性。
 * 3. 最后将对象绘制到当前空间或插入到块定义中。
 *
 * @example
 * ```ts
 * //参数绘直线 pt1,pt2是直线的两个点。
 * import { MxCpp, McDbLine } from "mxcad"'
 *
 * const line = new McDbLine(); // 构造直线对象
 * line.startPoint = pt1; // 设置直线起点
 * line.endPoint = pt2; // 设置直线终点
 * MxCpp.getCurrentMxCAD().drawEntity(line); // 绘制直线
 * ```
 * ```ts
   //交互绘线，点击画布选择直线的起始点。
   import { MxCADUiPrPoint, MxCpp } from "mxcad";
   
   async function MxTest_DrawLine() {
	// 取起始点
	const getPoint = new MxCADUiPrPoint();
	getPoint.setMessage("\n指定第一点:");
	let prvPoint = await getPoint.go();
	if (!prvPoint) return;
	getPoint.setMessage("\n指定下一个点:");
	// 循环取点
	while (true) {
		getPoint.setBasePt(prvPoint as any);
		let pt = await getPoint.go();
		if (!pt) return;
		let line = new McDbLine(prvPoint, pt);
		MxCpp.getCurrentMxCAD().drawEntity(line);
		prvPoint = pt;
	}
	}
 * ```
 */
export declare class McDbLine extends McDbCurve {
	/**
	 * 构造函数。
	 * @param imp C++ 实现对象。
	 * @example
	 * ```ts
	 * import { McDbLine, McGePoint3d } from 'mxcad';
	 *
	 * // 创建 McGePoint3d 对象表示起点和终点
	 * const startPoint = new McGePoint3d(0, 0, 0);
	 * const endPoint = new McGePoint3d(10, 10, 0);
	 * // 通过 McGePoint3d 对象创建 McDbLine 对象
	 * const line1 = new McDbLine(startPoint, endPoint);
	 * // 或者直接传入坐标值创建 McDbLine 对象
	 * const line2 = new McDbLine(0, 0, 0, 10, 10, 0);
	 * ```
	 */
	constructor(x1?: object | number, y1?: object | number, z1?: number, x2?: number, y2?: number, z2?: number);
	/**
	 * 获取起点。
	 */
	get startPoint(): McGePoint3d;
	/**
	 * 设置起点。
	 * @param pt 新的起点。
	 */
	set startPoint(pt: McGePoint3d);
	/**
	 * 获取终点。
	 */
	get endPoint(): McGePoint3d;
	/**
	 * 设置终点。
	 * @param pt 新的终点。
	 */
	set endPoint(pt: McGePoint3d);
}
/**
 * McDbText 是文本实体类，用于创建和管理单行文本对象。
 *
 * @description
 * 该类用于在图纸中添加单行文本，支持设置文字内容、高度、位置、旋转角度、对齐方式和文本样式。
 *
 * 使用方法总结：
 * 1. 先创建 McDbText 实例。
 * 2. 再设置文字内容、位置、旋转角度、对齐方式和文本样式。
 * 3. 最后将其插入当前空间并更新显示。
 *
 * @example
 * ```ts
 * //绘垂直中间对齐的文字 pt(McGePoint3d) 文字位置点
 * import { MxCpp, McDbText } from "mxcad"
 *
 * const text = new McDbText(); // 构造文字实体对象
 * text.textString = "测试文字"; // 设置对象内容
 * text.horizontalMode = McDb.TextHorzMode.kTextMid; // 设置文字对齐方式
 * text.alignmentPoint = text.position = pt; // 设置文字对齐点和文字位置
 * MxCpp.getCurrentMxCAD().drawEntity(text); // 绘制文字对象
 *
 * ```
 * ```ts
   // 按线对齐:选择文字对象按目标直线方向对齐
   import { MxCADResbuf, MxCADUiPrEntity } from "mxcad";

   async function Mx_AlignByLine() {
		// 选择目标直线对象
		let filter = new MxCADResbuf();
		filter.AddMcDbEntityTypes("LINE");
		const getLineObj = new MxCADUiPrEntity();
		getLineObj.setMessage("请选择目标对齐线对象(选择直线)");
		getLineObj.setFilter(filter);
		const lineObj_id = await getLineObj.go();
		if (!lineObj_id.id) return;
		const lineObj = lineObj_id.getMcDbEntity() as McDbLine;
		const getTextObj = new MxCADUiPrEntity();
		// 选择目标文字对象
		let filter2 = new MxCADResbuf();
		filter2.AddMcDbEntityTypes("TEXT");
		getTextObj.setMessage("请选择目标文字对象");
		getTextObj.setFilter(filter2);
		const textObj_id = await getTextObj.go();
		if (!textObj_id.id) return;
		const textObj = textObj_id.getMcDbEntity() as McDbText;
		// 计算直线与文字对象角度
		const line_v = lineObj.getFirstDeriv(lineObj.getStartPoint().val);// 直线初始点切向量
		let angle1 = line_v.val.angleTo2(McGeVector3d.kXAxis, McGeVector3d.kNegateZAxis);//直线与水平方向角度
		let angle2 = textObj.rotation;//文字初始角度
		textObj.rotate(textObj.position, angle1 - angle2) // 文字对象旋转
		const mxcad = MxCpp.App.getCurrentMxCAD();
		mxcad.updateDisplay() // 更新显示
   }
 * ```
 */
export declare class McDbText extends McDbEntity {
	/**
	 * 构造函数。
	 * @param imp 实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取文字的位置。
	 */
	get position(): McGePoint3d;
	/**
	 * 设置文字的位置。
	 * @param pt 三维点向量
	 */
	set position(pt: McGePoint3d);
	/**
	 * 获取文字的对齐点。
	 */
	get alignmentPoint(): McGePoint3d;
	/**
	 * 设置文字的对齐点。
	 * @param pt 三维点向量
	 */
	set alignmentPoint(pt: McGePoint3d);
	/**
	 * 获取文字的倾斜角度。
	 */
	get oblique(): number;
	/**
	 * 设置文字的倾斜角度。
	 */
	set oblique(val: number);
	/**
	 * 获取文字的旋转角度。
	 */
	get rotation(): number;
	/**
	 * 设置文字的旋转角度。
	 */
	set rotation(pt: number);
	/**
	 * 获取文字的高度。
	 */
	get height(): number;
	/**
	 * 设置文字高度
	 * @param val 高度
	 */
	set height(val: number);
	/**
	 * 获取文字的宽度因子。
	 */
	get widthFactor(): number;
	/**
	 * 设置文字的宽度因子。
	 * @param val 宽度因子
	 */
	set widthFactor(val: number);
	/**
	 * 获取文字的字符串。
	 */
	get textString(): string;
	/**
	 * 设置文字的字符串。
	 * @param val 字符串
	 */
	set textString(val: string);
	/**
	 * 获取文字的水平对齐方式。
	 */
	get horizontalMode(): McDb.TextHorzMode;
	/**
	 * 设置文字的水平对齐方式。
	 * @param val 文字水平对齐方式
	 * @example
	 * ```ts
	 * import { McDbText, McDb } from "mxcad";
	 *
	 * const text = new McDbText();
	 * text.horizontalMode = McDb.TextHorzMode.kTextAlign;
	 * console.log(text.horizontalMode)//3
	 * ```
	 */
	set horizontalMode(val: McDb.TextHorzMode);
	/**
	 * 获取文字的垂直对齐方式。
	 */
	get verticalMode(): McDb.TextVertMode;
	/**
	 * 设置文字的垂直对齐方式。
	 * @param val 文字垂直对齐方式
	 * @example
	 * ```ts
	 * import { McDbText, McDb } from "mxcad";
	 *
	 * const text = new McDbText();
	 * text.verticalMode = McDb.TextVertMode.kTextVertMid;
	 * console.log(text.verticalMode)//2
	 * ```
	 */
	set verticalMode(val: McDb.TextVertMode);
	/**
	 * 根据当前文字对齐方式，和对齐点，计算文字位置。
	 */
	adjustAlignment(): void;
}
/**
 * McDbAttribute 是属性实体类，用于表示块属性对象。
 *
 * @description
 * 该类用于处理块参照中的属性内容，常用于读取、修改和管理属性值。
 *
 * 使用方法总结：
 * 1. 先创建或获取 McDbAttribute 对象。
 * 2. 再设置属性标签、属性值及可见性等属性。
 * 3. 最后将其关联到对应的块定义或块参照中。
 *
 * @example
 * ```ts
	import { McDbBlockReference, McDbAttribute, MxCADUiPrEntity, MxCADResbuf, DxfCode } from "mxcad";

	// 遍历块中的属性文字
	async function Mx_Test() {
		const getBlock = new MxCADUiPrEntity();
		getBlock.setMessage('选择目标块');
		getBlock.setFilter(new MxCADResbuf([DxfCode.kEntityType, "INSERT"]));
		const block_id = await getBlock.go();
		if (!block_id.isValid()) return;
		let block = block_id.getMcDbEntity() as McDbBlockReference;
 
		let blkRef: McDbBlockReference = block;
		let aryId = blkRef.getAllAttribute();
		aryId.forEach((id) => {
			let attribt: McDbAttribute = id.getMcDbEntity() as any;
			console.log(attribt.textString);
			console.log(attribt.tag);
		})
	}
 * ```
 */
export declare class McDbAttribute extends McDbText {
	/**
	 * 构造函数。
	 * @param imp 实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取文字的字符串。
	 */
	get tag(): string;
	/**
	 * 设置文字的字符串。
	 */
	set tag(val: string);
	/**
	 * 获取块属性文字是否可见
	 */
	get isInvisible(): boolean;
	/**
	 * 设置块属性文字是否不可见
	 */
	set isInvisible(val: boolean);
}
/**
 * McDbAttributeDefinition 是属性定义类，用于定义块中的属性模板。
 *
 * @description
 * 该类用于创建块属性定义，定义属性的标签、默认值、显示行为和其他特性。
 *
 * 使用方法总结：构造属性定义对象后，设置属性字段并将其加入块定义中，随后由块参照实例化使用。
 * @example
 * ```ts
	import { McDbBlockReference, McDbAttribute, MxCADUiPrEntity, MxCADResbuf, DxfCode } from "mxcad"

	// 遍历图块中的属性定义对象
	async function Mx_TestBlkAttribute() {
		const getBlock = new MxCADUiPrEntity();
		getBlock.setMessage('选择目标块');
		getBlock.setFilter(new MxCADResbuf([DxfCode.kEntityType, "INSERT"]));
		const block_id = await getBlock.go();
		if (!block_id.isValid()) return;
		let block = block_id.getMcDbEntity() as McDbBlockReference;
		// 在块中插入属性文字
		let blkRef: McDbBlockReference = block;
		const blkrecId = blkRef.blockTableRecordId; // 获取块表记录id
		let blkRecord: any = blkrecId.getMcDbBlockTableRecord();// 获取块表记录对象
		let ids = blkRecord.getAllEntityId(); // 获取块表记录中所有实例对象ID
		ids.forEach((id: any, index: any) => {
			// 筛选 McDbAttributeDefinition 对象
			if (!id.isKindOf("McDbAttributeDefinition")) return;
			let attribDef = id.getMcDbEntity() as McDbAttributeDefinition;
			let tag = attribDef.tag; // 获取属性标签
			let txt = attribDef.textString; // 获取文字的字符串

			let attrib = new McDbAttribute(); // 构造新属性定义文字对象
			attrib.position = attribDef.position; // 设置对象位置
			attrib.alignmentPoint = attribDef.alignmentPoint // 设置对象对齐位置
			attrib.height = attribDef.height ; // 设置对象字高
			attrib.trueColor = attribDef.trueColor // 设置对象颜色
			attrib.widthFactor = attribDef.widthFactor; // 设置对象宽度因子
			// 设置文字的字符串
			if (txt.length > 0) attrib.textString = txt;
			else attrib.textString = "test" + index;
			attrib.tag = tag;// 设置属性标签
			attrib.isInvisible = attribDef.isInvisible;
			attrib.transformBy(blkRef.blockTransform); // 块转换
			attrib = blkRef.appendAttribute(attrib).getMcDbEntity() as McDbAttribute;
			attrib.textStyle = attribDef.textStyle
			attrib.layer = attribDef.layer
		})
	}
 * ```
   ```ts
   import { MxCpp, McDbBlockTableRecord, McDbLine, McDbCircle, McCmColor, McDbBlockReference, McGePoint3d, McDbAttributeDefinition, McDbAttribute } from "mxcad";

	// 画带属性定义的图块
	function drawBlock() {
		const mxcad = MxCpp.getCurrentMxCAD();
		// 创建新画布
		mxcad.newFile();

		// 先从数据库中得到图块表
		let blkTable = mxcad.getDatabase().getBlockTable();
		// 将一个新的图块记录添加到图块表中
		let blkRecId = blkTable.add(new McDbBlockTableRecord());

		// 根据ObjectId再次得到刚刚添加的图块记录
		let blkTableRecord = blkRecId.getMcDbBlockTableRecord()

		// 添加两条线段再图块记录中 这里每条线段的具体属性比如开始点和结束点自行赋值
		const line = new McDbLine(50, 50, 0, -50, -50, 0)
		line.trueColor = new McCmColor(0, 255, 0)
		const line1 = new McDbLine(-50, 50, 0, 50, -50, 0)
		const circle = new McDbCircle(0, 0, 0, 50)
		circle.trueColor = new McCmColor(255, 255, 0)
		blkTableRecord.appendAcDbEntity(line);
		blkTableRecord.appendAcDbEntity(line1);
		blkTableRecord.appendAcDbEntity(circle);
		const attribDef = new McDbAttributeDefinition();
		attribDef.tag = 'test';
		attribDef.textString = '测试文字';
		attribDef.position = new McGePoint3d(0, 0, 0);
		attribDef.alignmentPoint = new McGePoint3d(0, 0, 0);
		attribDef.height = 10;
		attribDef.widthFactor = 1;
		attribDef.trueColor = new McCmColor(255, 0, 0);
		attribDef.layer = "0";
		attribDef.isInvisible = false;
		blkTableRecord.appendAcDbEntity(attribDef)
		// 设置图块的基点 一般是包围盒内的点， 可以任意指定
		blkTableRecord.origin = new McGePoint3d(0, 0, 0);

		// 实例化块参照 这里需要设置我们刚刚添加图块记录得到的ObjectId
		let _blkRef = new McDbBlockReference();
		_blkRef.blockTableRecordId = blkRecId;
		// 最后设置位置 渲染图块
		_blkRef.position = new McGePoint3d(0, 0, 0);

		const id = mxcad.drawEntity(_blkRef);
		const blkRef = id.getMcDbEntity() as McDbBlockReference;
		// 如果块有属性定义，下面为块引创建属性定义。
		blkRef.createAttribute();
		blkRef.disableDisplay(true);
		blkRef.disableDisplay(false);
		mxcad.zoomAll()
		mxcad.zoomScale(0.8)
	};
   ```
 */
/**
 * 表示块属性定义实体，用于在块定义中定义属性标签和默认文字。
 * @description
 * McDbAttributeDefinition 是一种用于图块定义的文本属性实体，支持设置标签、显示文本、位置、对齐和可见性。
 * 它通常随块定义一起保存，块插入后可提示用户输入属性值，并在图形中显示该属性文本。
 * 使用方法:
 * 1. 创建 `McDbAttributeDefinition` 实例并设置 `tag`、`textString`、`position` 等属性。
 * 2. 将属性定义追加到块定义对象中。
 * 3. 插入块参照后，系统会根据定义提示用户填写属性值并显示属性文本。
 * @example
 * ```ts
 * import { McDbAttributeDefinition, McGePoint3d, McCmColor, McDbBlockTableRecord, McDbBlockReference, MxCpp } from "mxcad";
 *
 * const blockRecord = new McDbBlockTableRecord();
 * blockRecord.name = "TEST_BLOCK";
 * blockRecord.origin = new McGePoint3d(0, 0, 0);
 *
 * const attribDef = new McDbAttributeDefinition();
 * attribDef.tag = "MY_TAG";
 * attribDef.textString = "默认属性值";
 * attribDef.position = new McGePoint3d(10, 10, 0);
 * attribDef.alignmentPoint = new McGePoint3d(10, 10, 0);
 * attribDef.height = 12;
 * attribDef.widthFactor = 1;
 * attribDef.trueColor = new McCmColor(255, 0, 0);
 * attribDef.isInvisible = false;
 *
 * blockRecord.appendAcDbEntity(attribDef);
 *
 * const blockRef = new McDbBlockReference();
 * blockRef.blockTableRecordId = blockRecord.objectId;
 * blockRef.position = new McGePoint3d(0, 0, 0);
 * MxCpp.getCurrentMxCAD().drawEntity(blockRef);
 * ```
 */
export declare class McDbAttributeDefinition extends McDbText {
	/**
	 * 构造函数。
	 * @param imp 实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取文字的字符串。
	 */
	get tag(): string;
	/**
	 * 设置文字的字符串
	 */
	set tag(val: string);
	/**
	 * 获取是否可见
	 */
	get isInvisible(): boolean;
	/**
	 * 设置是否可见
	 */
	set isInvisible(val: boolean);
	/** 获取插入块实例时，提示用户输入值的文本 */
	get prompt(): string;
	/**
	 * 设置插入块实例时，提示用户输入值的文本
	 */
	set prompt(val: string);
	/** 获取指示属性是否是常量 */
	get isConstant(): boolean;
	/**
	 * 设置指示属性是否是常量
	 */
	set isConstant(val: boolean);
	/** 获取属性是否可验证 */
	get isVerifiable(): boolean;
	/**
	 * 设置属性是否可验证
	 */
	set isVerifiable(val: boolean);
	/** 获取属性是否预设 */
	get isPreset(): boolean;
	/**
	 * 设置属性是否预设
	 */
	set isPreset(val: boolean);
}
/**
 * McDbMText 是多行文字实体类，用于创建和编辑多行文本对象。
 *
 * @description
 * 该类用于在图纸中插入多行文字，支持设置内容、宽度、高度、位置和文本样式。
 *
 * 使用方法总结：
 * 1. 先创建 McDbMText 实例。
 * 2. 再设置其内容、宽度、高度、位置和附着点等布局参数。
 * 3. 最后将其加入当前空间并显示。
 *
 * @example
 * ```ts
  // 绘制多行文本
  import { McDbMText, MxCpp } from 'mxcad'
  
  const mText = new McDbMText();// 构造新多行文本对象
  mText.textHeight = 10;// 设置文本高度
  mText.attachment = McDb.AttachmentPoint.kMiddleLeft;// 设置文本对齐方式
  mText.contents = '控件：\\P 多行文本'; // 设置文本内容
  mText.location = new McGePoint3d(0,0,0); // 设置文本位置
  MxCpp.getCurrentMxCAD().drawEntity(mText); // 绘制多行文本
 * ```
 */
export declare class McDbMText extends McDbEntity {
	/**
	 * 构造函数
	 * @param imp 实现对象
	 */
	constructor(imp?: any);
	/**
	 * 获取位置
	 * @returns 位置点
	 */
	get location(): McGePoint3d;
	/**
	 * 设置位置
	 * @param pt 位置点
	 */
	set location(pt: McGePoint3d);
	/**
	 * 获取旋转角度
	 * @returns 旋转角度
	 */
	get rotation(): number;
	/**
	 * 设置旋转角度
	 * @param val 旋转角度
	 */
	set rotation(val: number);
	/**
	 * 获取宽度
	 * @returns 宽度
	 */
	get width(): number;
	/**
	 * 设置宽度
	 * @param val 宽度
	 */
	set width(val: number);
	/**
	 * 获取文本高度
	 * @returns 文本高度
	 */
	get textHeight(): number;
	/**
	 * 设置文本高度
	 * @param val 文本高度
	 */
	set textHeight(val: number);
	/**
	 * 获取附着点
	 * @returns 附着点
	 */
	get attachment(): McDb.AttachmentPoint;
	/**
	 * 设置附着点
	 * @param val 附着点
	 */
	set attachment(val: McDb.AttachmentPoint);
	/**
	 * 获取文本内容
	 * @returns 文本内容
	 */
	get contents(): string;
	/**
	 * 设置文本内容
	 * @param val 文本内容
	 */
	set contents(val: string);
	/**
   * 获取文本不带格式控制符的内容
   * @returns 不带格式控制符的内容
   */
	getTextString(): string;
	/**
	 * 重新计算多行文档的格式控制符对多行文本的显示数据。
	 */
	reCompute(): boolean;
}
/**
 * McDbCircle 是圆实体类，用于创建和管理圆形对象。
 *
 * @description
 * 该类用于在图纸中创建圆对象，支持设置圆心、半径、颜色、图层和线型。
 *
 * 使用方法总结：
 * 1. 先创建 McDbCircle 实例。
 * 2. 再设置圆心坐标和半径，并配置图层、颜色和线型。
 * 3. 最后将其绘制到当前空间或插入到块定义中。
 *
 * @example
 * ```ts
	import {McDbCircle, MxCADUiPrDist, MxCADUiPrPoint, MxCpp} from "mxcad";

	// 画圆
	async function Mx_drawCircle(){
		// 创建圆
		const circle = new McDbCircle();

		// 获取圆心
		const getCenter = new MxCADUiPrPoint();
		getCenter.setMessage('请确定圆心位置\n');
		const center = await getCenter.go();
		if (!center) return;
		circle.center = center;

		// 获取圆半径
		const getRadius = new MxCADUiPrDist();
		getRadius.setBasePt(center);
		getRadius.setMessage('请输入圆半径');
		// 动态绘制圆
		getRadius.setUserDraw((pt, pw) => {
			const r = pt.distanceTo(center);
			circle.radius = r;
			pw.drawMcDbEntity(circle)
		})
		const radiusVal = await getRadius.go();
		if (!radiusVal) return;
		circle.radius = getRadius.value();

		// 绘制圆
		const mxobj = MxCpp.getCurrentMxCAD();
		mxobj.drawEntity(circle);
	};
 * ```
 */
export declare class McDbCircle extends McDbCurve {
	/**
	 * 构造函数。
	 * @param imp 内部对象。
	 * @example
	 * ```ts
	 * import { McDbCircle } from 'mxcad'
	 *
	 * //绘制一个圆心在原点，半径为20的圆
	 * const circle1 = new McDbCircle(new McGePoint3d(0,0,0), 20);
	 * //绘制一个圆心在原点，半径为10的圆
	 * const circle2 = new McDbCircle(0, 0, 0, 10);
	 * ```
	 */
	constructor(x?: object | number, y?: number, z?: number, radius?: number);
	/**
	 * 设置圆心坐标。
	 * @param x 圆心 x 坐标。
	 * @param y 圆心 y 坐标。
	 * @param z 圆心 z 坐标。
	 */
	setCenter(x: number, y: number, z?: number): void;
	/**
	 * 获取圆心坐标。
	 */
	get center(): McGePoint3d;
	/**
	 * 设置圆心坐标。
	 * @param pt 圆心坐标。
	 */
	set center(pt: McGePoint3d);
	/**
	 * 获取圆半径。
	 */
	get radius(): number;
	/**
	 * 设置圆半径。
	 * @param r 圆半径。
	 */
	set radius(r: number);
}
/**
 * McDbPolyline 是多段线实体类，用于创建和管理多段线对象。
 *
 * @description
 * 该类用于绘制由多段线段组成的复杂图形，支持设置顶点、闭合状态、宽度和显示属性。
 *
 * 使用方法总结：
 * 1. 先创建 McDbPolyline 实例。
 * 2. 再依次添加顶点并设置闭合状态、常量宽度和凸度等样式参数。
 * 3. 最后将其加入当前空间并显示。
 *
 * @example
 * ```ts
 * import { McDbPolyline, MxCpp } from 'mxcad'
 * //绘制线宽为10的矩形，pt1,pt2,pt3,pt4为矩形的4点个顶点
 * const pl = new McDbPolyline();
 * pl.constantWidth = 10;// 设置多段线线宽为10
 * // 设置多段线端点
 * pl.addVertexAt(pt1);
 * pl.addVertexAt(pt2);
 * pl.addVertexAt(pt3);
 * pl.addVertexAt(pt4);
 * pl.isClosed = true; // 设置多段线是否闭合
 * MxCpp.getCurrentMxCAD().drawEntity(pl); // 绘制多段线
 * ```
 * ```ts
  // 绘制中心矩形：指定矩形宽高与中心点，动态绘制矩形
  import { McDbPolyline, MxCpp, MxCADUiPrDist, MxCADUiPrPoint } from 'mxcad';

  async function Mx_CenterRect() {
	// 设置矩形宽度
	let width = 5;
	const getWidth = new MxCADUiPrDist();
	getWidth.setMessage("\n请输入矩形宽度<5>");
	const widthVal = await getWidth.go();
	if (widthVal) {
		width = getWidth.value()
	}
	// 设置矩形高度
	let height = 10;
	const getHeight = new MxCADUiPrDist();
	getHeight.setMessage("\n请输入矩形高度<10>");
	const heightVal = await getHeight.go();
	if (heightVal) {
		height = getHeight.value()
	}
	// 设置矩形的中心点
	const getCenterPt = new MxCADUiPrPoint();
	getCenterPt.setMessage("请点击确定矩形中心");
	const centerPt = await getCenterPt.go();
	if (!centerPt) return;
	// 根据矩形的中心点和宽高计算矩形的四个顶点
	let pt1 = new McGePoint3d(centerPt.x + width / 2, centerPt.y + height / 2, centerPt.z)
	let pt2 = new McGePoint3d(centerPt.x - width / 2, centerPt.y + height / 2, centerPt.z)
	let pt3 = new McGePoint3d(centerPt.x - width / 2, centerPt.y - height / 2, centerPt.z)
	let pt4 = new McGePoint3d(centerPt.x + width / 2, centerPt.y - height / 2, centerPt.z)
	let pl = new McDbPolyline;// 构造一个多段线对象
	// 依次添加矩形顶点
	pl.addVertexAt(pt1)
	pl.addVertexAt(pt2)
	pl.addVertexAt(pt3)
	pl.addVertexAt(pt4)
	const mxcad = MxCpp.App.getCurrentMxCAD();
	pl.isClosed = true; // 设置多段线闭合
	mxcad.drawEntity(pl); // 绘制多段线对象
  }
 * ```
 */
export declare class McDbPolyline extends McDbCurve {
	/**
	 * 构造函数
	 * @param imp 实现对象
	 */
	constructor(imp?: any);
	/**
	 * 获取是否闭合
	 */
	get isClosed(): boolean;
	/**
	 * 设置是否闭合
	 * @param val 是否闭合
	 */
	set isClosed(val: boolean);
	/**
	 * 获取常量宽度
	 */
	get constantWidth(): number;
	/**
	 * 设置常量宽度
	 * @param val 常量宽度
	 */
	set constantWidth(val: number);
	/**
	 * 在指定位置添加顶点
	 * @param index 位置
	 * @param pt 点
	 * @param bulge 凸度
	 * @param startWidth 起始宽度
	 * @param endWidth 结束宽度
	 * @example
	 * ```ts
	 * import { McDbPolyline, MxCpp } from "mxcad";
	 *
	 * const pl = new McDbPolyline();
	 * pl.isClosed = true;
	 * pl.addVertexAt(new McGePoint3d(800, 300, 0),0,10,10);
	 * pl.addVertexAt(new McGePoint3d(900, 300, 0),0,10,10);
	 * pl.addVertexAt(new McGePoint3d(900, 400, 0),0,10,10);
	 * MxCpp.getCurrentMxCAD().drawEntity(pl);
	 * ```
	 */
	addVertexAt(pt: McGePoint3d | THREE.Vector3, bulge?: number, startWidth?: number, endWidth?: number, index?: number): boolean;
	/**
	 * 移除指定位置的顶点
	 * @param index 位置
	 */
	removeVertexAt(index: number): boolean;
	/**
	 * 获取顶点数量
	 */
	numVerts(): number;
	/**
	 * 获取指定位置的点
	 * @param index 位置
	 * @returns val: 点, ret: 返回值
	 */
	getPointAt(index: number): {
		val: McGePoint3d;
		ret: number;
	};
	/**
	 * 获取指定位置的凸度
	 * @param index 位置
	 */
	getBulgeAt(index: number): number;
	/**
	 * 获取指定位置的起始和结束宽度
	 * @param index 位置
	 * @returns val1: 起始宽度, val2: 结束宽度, ret: 返回值
	 */
	getWidthsAt(index: number): {
		val1: number;
		val2: number;
		ret: boolean;
	};
	/**
	 * 设置指定位置的点
	 * @param index 位置
	 * @param pt 点
	 */
	setPointAt(index: number, pt: McGePoint3d): boolean;
	/**
	 * 设置指定位置的凸度
	 * @param index 位置
	 * @param bulge 凸度
	 */
	setBulgeAt(index: number, bulge: number): boolean;
	/**
	 * 判断一个点是否在多线段组成闭合区域内
	 */
	pointInPolygon(x: number, y: number): boolean;
	/**
	 * 修改线段的开始宽度，和结束宽度
	 * @param index 位置
	 * @param bulge 凸度
	 */
	setWidthsAt(index: number, dStartWdith: number, dEntWdith: number): boolean;
	/**
	 * 设置多线段类型
	 */
	getType(): McDb.PolylineType;
	/**
	 * 返回多线段类型
	 * @param type 多线段类型
	 */
	setType(type: McDb.PolylineType): boolean;
	/**
	* 多线段坐标点反向
	* @param type 多线段类型
	*/
	reverse(): boolean;
	/**
	* 缩放多线段的宽度
	*/
	sclaeWidth(scale: number): boolean;
}
/**
 * McDbBlockReference 是块参照实体类，用于在图纸中插入块实例。
 *
 * @description
 * 该类用于表示 CAD 中的块引用对象，能够根据块定义显示出实例化的图块内容。
 *
 * 使用方法总结：
 * 1. 先创建或获取块定义。
 * 2. 再实例化 McDbBlockReference，并设置其块表记录 ID、插入位置、缩放和旋转等属性。
 * 3. 最后将其显示到当前空间中。
 *
 * @example
 * ```ts
	import { McDbBlockReference, MxCADUiPrPoint, MxCpp } from "mxcad";

	// 插入图块
	async function MxTest_InsertBlock() {
		let baseUrl = "http://localhost:3000/mxcad/"
		// 设置图块路径
		let blkFilePath = baseUrl + "tree.mxweb";

		// 插入图块文件
		let mxcad = MxCpp.App.getCurrentMxCAD();
		let blkrecId = await mxcad.insertBlock(blkFilePath, "tree");
		if (!blkrecId.isValid()) {
			// 插入图块
			return;
		}

		// 设置图块大小
		let blkRef = new McDbBlockReference();
		blkRef.blockTableRecordId = blkrecId;
		let box = blkRef.getBoundingBox();
		if (box.ret) {
			let dLen = box.maxPt.distanceTo(box.minPt);
			if (dLen > 0.00001) {
				blkRef.setScale(mxcad.getMxDrawObject().screenCoordLong2Doc(100) / dLen);
			}
		}

		// 指定插入基点
		let getPoint = new MxCADUiPrPoint();
		getPoint.setMessage("\指定插入基点");

		// 动态绘制图块
		getPoint.setUserDraw((v, worldDraw) => {
			blkRef.position = v;
			worldDraw.drawMcDbEntity(blkRef);
		});

		let pt = await getPoint.go();
		if (!pt) return;
		blkRef.position = pt;
		// 绘制图块
		let newBlkRefId = mxcad.drawEntity(blkRef);
		if (!newBlkRefId.isValid) {
			console.log("insert error");
			return;
		}
	};
 * ```
 * */
export declare class McDbBlockReference extends McDbEntity {
	/**
	 * 初始化一个新的 McDbBlockReference 实例。
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置该实体所引用的图块的 ID。
	 */
	get blockTableRecordId(): McObjectId;
	set blockTableRecordId(val: McObjectId);
	/**
	 * 获取或设置该实体的位置。
	 */
	get position(): McGePoint3d;
	set position(pt: McGePoint3d);
	/**
	 * 获取或设置该实体的缩放因子。
	 */
	get scaleFactors(): McGePoint3d;
	set scaleFactors(val: McGePoint3d);
	/**
	 * 设置和获取对象的缩放比例
	 * @param val 缩放比例
	 */
	setScale(val: number): void;
	getScale(): number;
	/**
	 * 获取或设置该实体的旋转角度。
	 */
	get rotation(): number;
	set rotation(val: number);
	/**
	 * 获取或设置该实体所引用的图块的变换矩阵。
	 */
	get blockTransform(): McGeMatrix3d;
	set blockTransform(val: McGeMatrix3d);
	/**
	 * 获取块名
	 * @returns 块名
	 */
	get blockName(): string;
	/**
	 * 添加属性文字对象
	 * @param attrib 属性定义文字
	 * @returns 对象Id
	 */
	appendAttribute(attrib: McDbAttribute): McObjectId;
	/**
	 * 得到块引用的所有属性文字对象id
	 * @returns 属性文字对象id数组
	 */
	getAllAttribute(): McObjectId[];
	/**
	 * 通过块表记录中的属性定义创建属性文字对象
	 */
	createAttribute(): boolean;
	/**
	* 得到剪切边界对象
	* @returns

	*/
	getSpatialFilterId(): McObjectId;
	/**
	* 创建剪切边界对象，如果剪切边界已经存在就直接返回
	* @returns

	*/
	createSpatialFilter(): boolean;
	/**
	 * 清空当前剪切边界显示缓存，当前边界对象被修改后，使用该函数清理缓存，更新显示.
	 * @returns

	 */
	clearSpatialFilterCache(): boolean;
	/**
	* 把块引用的属性拷到到另一个块引上，被拷贝的块引用必须在图形数据库中。
	* @returns

	*/
	copyAttribute(to: McDbBlockReference): boolean;
	/**
	 * 删除块引用的所有属性
	 * @returns

	 */
	eraseAllAttribute(): void;
}
/**
 * McDbSpatialFilter 是空间过滤器类，用于按空间范围筛选对象。
 *
 * @description
 * 该类用于构造空间筛选条件，对对象集合进行范围过滤。
 *
 * 使用方法总结：
 * 1. 先创建 McDbSpatialFilter 对象。
 * 2. 再配置其边界点集和启用状态。
 * 3. 最后将其用于查询或筛选满足空间条件的实体对象。
 *
 * @example
 * ```ts
	import { MxCADSelectionSet, MxCpp, McDbBlockTableRecord, McDbEntity, McGePoint3d, McDbBlockReference, McDbCircle, McGePoint3dArray, McDbSpatialFilter } from "mxcad";

	// 创建边缘裁剪块
	async function MxTest_SelectEntitysToSpatialFilterBlock() {
		let ss = new MxCADSelectionSet();
		if (!await ss.userSelect("选择要做成块的对象:")) return;
		if (ss.count() == 0) return;

		let mxcad = MxCpp.getCurrentMxCAD();
		let blkTable = mxcad.getDatabase().getBlockTable();
		let blkRec = new McDbBlockTableRecord();
		let blkRecId = blkTable.add(blkRec);
		let blkTableRecord: McDbBlockTableRecord = blkRecId.getMcDbBlockTableRecord() as any;
		if (blkTableRecord == null) return;

		let pt1x: any, pt1y: any, pt2x: any, pt2y: any;
		ss.forEach((id) => {
			let ent = id.getMcDbEntity();
			if (!ent) return;

			let cent = ent.clone() as McDbEntity;
			blkTableRecord.appendAcDbEntity(cent);

			let entBox = ent.getBoundingBox();
			if (entBox.ret) {
				if (!pt1x) {
					pt1x = entBox.minPt.x;
					pt1y = entBox.minPt.y;
					pt2x = entBox.maxPt.x;
					pt2y = entBox.maxPt.y;
				}
				else {
					if (pt1x > entBox.minPt.x) pt1x = entBox.minPt.x;
					if (pt1y > entBox.minPt.y) pt1y = entBox.minPt.y;
					if (pt2x < entBox.maxPt.x) pt2x = entBox.maxPt.x;
					if (pt2y < entBox.maxPt.y) pt2y = entBox.maxPt.y;
				}
			}
		})
		if (pt1x === undefined) {
			return;
		}
		let insertPtx = pt1x + (pt2x - pt1x) * 0.5;
		let insertPty = pt1y + (pt2y - pt1y) * 0.5;
		// 设置图块的插入基点，在图形对象的中心位置。
		blkTableRecord.origin = new McGePoint3d(insertPtx, insertPty, 0);


		let blkRef = new McDbBlockReference();
		blkRef.blockTableRecordId = blkRecId;
		blkRef.position = new McGePoint3d(insertPtx + (pt2x - pt1x) * 3, insertPty + (pt2y - pt1y) * 3, 0);

		blkRef = mxcad.drawEntity(blkRef).getMcDbEntity() as McDbBlockReference;


		// 设置一个圆做它的剪切边界.
		let dR = (pt2x - pt1x);
		if (dR < (pt2y - pt1y)) dR = (pt2y - pt1y);
		dR *= 0.3;
		let circle = new McDbCircle(insertPtx, insertPty, 0, dR);
		let samplePoints = circle.getSamplePoints(dR * 0.00001);
		let aryPoint = new McGePoint3dArray();
		samplePoints.forEach((val, _type, dxf) => {
			if (dxf === 1010) {
				const point = new McGePoint3d(val.x, val.y, val.z)
				aryPoint.append(point);
			}
		});

		blkRef.createSpatialFilter();
		blkRef.scaleFactors = new McGePoint3d(3, 3, 3);
		let idSpatialFilter = blkRef.getSpatialFilterId();
		let blkFilter: McDbSpatialFilter = idSpatialFilter.getMcDbObject() as any;
		blkFilter.setBoundary(aryPoint);
		circle.center = blkRef.position;
		circle.radius = circle.radius * 3;
		mxcad.drawEntity(circle);
	};
 * ```
 * */
export declare class McDbSpatialFilter extends McDbObject {
	/**
	 * 初始化一个新的 McDbSpatialFilter 实例。
	 */
	constructor(imp?: any);
	/**
	 * 返回剪切边界数组点.
	 * @returns McGePoint3dArray
	 */
	boundary(): McGePoint3dArray;
	/**
	 * 设置剪切边界数组点，点坐标是块引用的块表记录中的坐标。
	 * @returns boolean
	 */
	setBoundary(aryPoint: McGePoint3dArray): boolean;
	/**
	* 剪切边界是否反向
	* @returns boolean
	*/
	isFilterInverted(): boolean;
	/**
	 * 设置剪切边界反向
	 * @returns boolean
	 */
	setFilterInverted(val: boolean): boolean;
	/**
	* 是否启用剪切边界
	* @returns boolean
	*/
	isEnabled(): boolean;
	/**
	 * 设置是否启用剪切边界
	 * @returns boolean
	 */
	setEnable(val: boolean): boolean;
}
/**
 * McDbDimension 是尺寸标注实体类的基类，用于统一管理尺寸对象的行为。
 *
 * @description
 * 该类用于表示尺寸标注对象，提供尺寸样式、文字、箭头和测量值关联等通用能力。
 *
 * 使用方法总结：
 * 1. 先通过 McDbAlignedDimension、McDbRotatedDimension 等子类实例化尺寸对象。
 * 2. 再为尺寸基线点、尺寸线点和文字位置赋值，并设置标注样式。
 * 3. 最后将其绘制到当前空间中。
 *
 * @example
 * ```ts
 *  // 修改标注样式
	import { MxCADUiPrEntity, MxCpp } from "mxcad";

	async function Mx_Test_ChangeDimStyle() {
		const mxcad = MxCpp.getCurrentMxCAD()
		// 选择对象
		let selEntity = new MxCADUiPrEntity();
		selEntity.setMessage("选择对象");
		let id = await selEntity.go();
		if (!id.isValid()) return;

		// 获取对象
		let ent = id.getMcDbEntity();
		if (ent === null) return;
		// 修改标注样式
		id.getMcDbDimension().setDimVarInt(176, 122);
		id.getMcDbDimension().setDimVarInt(177, 122);
		id.getMcDbDimension().setDimVarInt(178, 122);

		mxcad.updateDisplay()
	}
 * ```
 * */
export declare class McDbDimension extends McDbEntity {
	constructor(imp?: any);
	/**
	 * 获取文本位置
	 * @returns 文本位置
	 */
	get textPosition(): McGePoint3d;
	/**
	 * 设置文本位置
	 * @param pt 文本位置
	 */
	set textPosition(pt: McGePoint3d);
	/**
	 * 是否使用默认文本位置
	 * @returns 是否使用默认文本位置
	 */
	isUsingDefaultTextPosition(): boolean;
	/**
	 * 使用设置的文本位置
	 */
	useSetTextPosition(): void;
	/**
	 * 使用默认文本位
	 */
	useDefaultTextPosition(): void;
	/**
	 * 获取或设置高度
	 * @param val 高度
	 */
	get elevation(): number;
	set elevation(val: number);
	/**
	 * 获取或设置标注文本
	 * @param val 标注文本
	 */
	get dimensionText(): string;
	set dimensionText(val: string);
	/**
	 * 获取或设置文本旋转角度
	 * @param val 文本旋转角度
	 */
	get textRotation(): number;
	set textRotation(val: number);
	/**
	 * 设置标注样式id
	 * @param val 标注样式id
	 */
	get dimensionStyle(): McObjectId;
	set dimensionStyle(val: McObjectId);
	/**
	 * 获取或设置文本附着点
	 * @returns 文本附着点
	 */
	get textAttachment(): McDb.AttachmentPoint;
	set textAttachment(val: McDb.AttachmentPoint);
	/**
	 * 需要更新标注块
	 */
	needToUpdateDimBlock(need: boolean): void;
	/**
	 * 获取或设置水平旋转角度
	 * @returns 水平旋转角度
	 */
	get horizontalRotation(): number;
	set horizontalRotation(val: number);
	/**
	 * 重新计算标注块
	 */
	recomputeDimBlock(forceUpdate?: boolean, onlyCloneDimBlockRecord?: boolean): void;
	/**
	 * 获取标注变量整数值
	 * @param iType 标注变量类型
	 * @returns 标注变量整数值
	 */
	getDimVarInt(iType: number): number;
	/**
	 * 设置标注变量整数值
	 * @param iType 标注变量类型
	 * @param val 标注变量整数值
	 */
	setDimVarInt(iType: number, val: number): void;
	/**
	 * 获取标注变量浮点数值
	 * @param iType 标注变量类型
	 * @returns 标注变量浮点数值
	 */
	getDimVarDouble(iType: number): number;
	/**
	 * 设置标注变量浮点数值
	 * @param iType 标注变量类型
	 * @param val 标注变量浮点数值
	 */
	setDimVarDouble(iType: number, val: number): void;
	/**
	 * 获取标注变量字符串值
	 * @param iType 标注变量类型
	 * @returns 标注变量字符串值
	 */
	getDimVarString(iType: number): string;
	/**
	 * 设置标注变量字符串值
	 * @param iType 标注变量类型
	 * @param val 标注变量字符串值
	 */
	setDimVarString(iType: number, val: string): void;
	/**
	 * 获取标注变量对象 ID
	 * @param iType 标注变量类型
	 * @returns 标注变量对象 ID
	 */
	getDimVarObjectId(iType: number): McObjectId;
	/**
	 * 设置标注变量对象 ID
	 * @param iType 标注变量类型
	 * @param val 标注变量对象 ID
	 */
	setDimVarObjectId(iType: number, val: McObjectId): void;
	/**
	 * 得到标注对象中的所有文字内容
	 * @returns McGeStringArray 字符串数组
	 */
	GetAllText(): McGeStringArray;
}
/**
 * McDbAlignedDimension 是对齐尺寸标注类，用于创建对齐方向的尺寸标注。
 *
 * @description
 * 该类用于创建对齐尺寸对象，适合表示两点之间沿固定方向的尺寸标注。
 *
 * 使用方法总结：
 * 1. 先创建 McDbAlignedDimension 对象。
 * 2. 再设置第一条参考线端点、第二条参考线端点、尺寸线端点和标注样式。
 * 3. 最后将其加入当前空间并显示。
 *
 * @example
 * ```ts
   //绘制对齐标注
   import { McDbAlignedDimension, MxCpp } from "mxcad"
   
   const mDimension = new McDbAlignedDimension() // 构造对齐标注对象
   mDimension.xLine1Point = new McGePoint3d(-1800, 800) // 设置对象第一条线的端点
   mDimension.xLine2Point = new McGePoint3d(1800,800) // 设置对象第二条线的端点
   mDimension.dimLinePoint = new McGePoint3d(800, 500) // 设置对象标注线的端点
   mDimension.textAttachment = McDb.AttachmentPoint.kTopLeft // 设置对象文本对齐方式
   mDimension.trueColor = new McCmColor(200, 255, 0) // 设置对象颜色
   mDimension.oblique = 0 // 设置对象倾斜角度
   MxCpp.getCurrentMxCAD().drawEntity(mDimension); //绘制对齐标注对象
 * ```
 * */
export declare class McDbAlignedDimension extends McDbDimension {
	/**
	 * 构造函数
	 * @param imp 内部实现对象
	 */
	constructor(imp?: any);
	/**
	 * 获取第一条线的端点
	 * @returns 第一条线的端点
	 */
	get xLine1Point(): McGePoint3d;
	/**
	 * 设置第一条线的端点
	 * @param pt 第一条线的端点
	 */
	set xLine1Point(pt: McGePoint3d);
	/**
	 * 获取第二条线的端点
	 * @returns 第二条线的端点
	 */
	get xLine2Point(): McGePoint3d;
	/**
	 * 设置第二条线的端点
	 * @param pt 第二条线的端点
	 */
	set xLine2Point(pt: McGePoint3d);
	/**
	 * 获取标注线的端点
	 * @returns 标注线的端点
	 */
	get dimLinePoint(): McGePoint3d;
	/**
	 * 设置标注线的端点
	 * @param pt 标注线的端点
	 */
	set dimLinePoint(pt: McGePoint3d);
	/**
	 * 获取倾斜角度
	 * @returns 倾斜角度
	 */
	get oblique(): number;
	/**
	 * 设置倾斜角度
	 * @param val 倾斜角度
	 */
	set oblique(val: number);
}
/**
 * McDbRotatedDimension 是旋转尺寸标注类，用于创建带倾斜方向的尺寸标注。
 *
 * @description
* 该类用于创建旋转尺寸对象，适合表示与基准线呈角度关系的尺寸标注。
 *
 * 使用方法总结：
 * 1. 先创建 McDbRotatedDimension 对象。
 * 2. 再设置参考线端点、尺寸线端点、旋转角度和文字样式。
 * 3. 最后将其加入当前空间并显示。
 *
 * @example
 * ```ts
	//旋转标注
	import { McDbRotatedDimension, MxCpp } from "mxcad"

	const rDimension = new McDbRotatedDimension()  // 构造旋转标注对象
	rDimension.xLine1Point = new McGePoint3d(-1800, -800) // 设置对象第一条线的端点
	rDimension.xLine2Point = new McGePoint3d(1800, -800) // 设置对象第二条线的端点
	rDimension.dimLinePoint = new McGePoint3d(-800, -500) // 设置对象标注线的端点
	rDimension.textAttachment = McDb.AttachmentPoint.kTopLeft // 设置对象文本对齐方式
	rDimension.textRotation = 0.6 // 设置对象文字旋转角度
	rDimension.trueColor = new McCmColor(200, 255, 0) // 设置对象颜色
	rDimension.oblique = 0  // 设置对象倾斜角度
	rDimension.rotation = 0 // 设置对象旋转角度
	rDimension.dimensionText = "标注文本" // 设置对象文本内容
	MxCpp.getCurrentMxCAD().drawEntity(rDimension);//绘制旋转标注对象
 * ```
 * */
export declare class McDbRotatedDimension extends McDbDimension {
	/**
	 * 构造函数
	 * @param imp 内部实现对象
	 */
	constructor(imp?: any);
	/**
	 * 获取第一条线的端点
	 * @returns 第一条线的端点
	 */
	get xLine1Point(): McGePoint3d;
	/**
	 * 设置第一条线的端点
	 * @param pt 第一条线的端点
	 */
	set xLine1Point(pt: McGePoint3d);
	/**
	 * 获取第二条线的端点
	 * @returns 第二条线的端点
	 */
	get xLine2Point(): McGePoint3d;
	/**
	 * 设置第二条线的端点
	 * @param pt 第二条线的端点
	 */
	set xLine2Point(pt: McGePoint3d);
	/**
	 * 获取标注线的端点
	 * @returns 标注线的端点
	 */
	get dimLinePoint(): McGePoint3d;
	/**
	 * 设置标注线的端点
	 * @param pt 标注线的端点
	 */
	set dimLinePoint(pt: McGePoint3d);
	/**
	 * 获取倾斜角度
	 * @returns 倾斜角度
	 */
	get oblique(): number;
	/**
	 * 设置倾斜角度
	 * @param val 倾斜角度
	 */
	set oblique(val: number);
	/**
	 * 获取旋转角度
	 * @returns 旋转角度
	 */
	get rotation(): number;
	/**
	 * 设置旋转角度
	 * @param val 旋转角度
	 */
	set rotation(val: number);
}
/**
 * McDb2LineAngularDimension 表示两条线角度标注对象。
 *
 * @description
 * 该类用于创建和配置基于两条线的角度标注尺寸对象，可用于在 CAD 中绘制角度测量标注。
 * 它支持设置第一参考线和第二参考线的起点与终点，以及角度标注显示位置。
 * 该对象通常用于标注两条线所夹角度，并以标准尺寸方式在图形中显示角度值。
 * 使用方法总结：
 * 1. 创建 `McDb2LineAngularDimension` 实例；
 * 2. 设置 `xLine1Start`、`xLine1End`、`xLine2Start`、`xLine2End` 等参考线坐标；
 * 3. 通过 `arcPoint` 指定标注显示位置后，将对象绘制到当前 CAD 中。
 *
 * @example
 * ```ts
   import { MxCpp, MxDb2LineAngularDimension, MxCADUiPrPoint } from "mxcad";
   // 下面代码演示了，先选择需要测量角度的两条边，再设置角度标注位置，最后绘制出角度标注对象。
   function BR_AngleMeasure() {
		const angleDim = new McDb2LineAngularDimension();// 构造新角度标注尺寸对象
		// 设置角边1起点
		const getPoint1 = new MxCADUiPrPoint()
		getPoint1.setMessage("\n指定线1起点:");
		const point1 = await getPoint1.go();
		if(!point1) return;
		angleDim.xLine1Start = point1;
		// 设置角边1终点
		const getPoint2 = new MxCADUiPrPoint()
		getPoint1.setMessage("\n指定线1终点:");
		const point2 = await getPoint2.go();
		if(!point2) return;
		angleDim.xLine1End = point2;
		// 设置角边2起点
		const getPoint3 = new MxCADUiPrPoint()
		getPoint3.setMessage("\n指定线2起点:");
		const point3 = await getPoint3.go();
		if(!point3) return;
		angleDim.xLine2Start = point3;
		// 设置角边2终点
		const getPoint4 = new MxCADUiPrPoint();
		getPoint4.setMessage("\n指定线2终点:");
		const point4 = await getPoint4.go();
		if(!point4) return;
		angleDim.xLine2End = point4;
		// 设置角度标注位置
		const getArcPoint = new MxCADUiPrPoint()
		getPoint3.setMessage("\n指定标注点:");
		const arcPoint = await getArcPoint.go();
		if(!arcPoint) return;
		angleDim.arcPoint = arcPoint;
		// 绘制角度标注尺寸对象
		MxCpp.getCurrentMxCAD().drawEntity(angleDim);
   }
 * ```
 * */
export declare class McDb2LineAngularDimension extends McDbDimension {
	/**
	 * 构造函数
	 * @param imp 内部实现对象
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置角度标注在圆弧上的点
	 * @returns 角度标注在圆弧上的点
	 */
	get arcPoint(): McGePoint3d;
	set arcPoint(pt: McGePoint3d);
	/**
	 * 获取或设置角度标注第一个参考线的开始点
	 * @returns 角度标注第一个参考线的开始点
	 */
	get xLine1Start(): McGePoint3d;
	set xLine1Start(pt: McGePoint3d);
	/**
	 * 获取或设置角度标注第一个参考线的结束点
	 * @returns 角度标注第一个参考线的结束点
	 */
	get xLine1End(): McGePoint3d;
	set xLine1End(pt: McGePoint3d);
	/**
	 * 获取或设置角度标注第二个参考线的开始点
	 * @returns 角度标注第二个参考线的开始点
	 */
	get xLine2Start(): McGePoint3d;
	set xLine2Start(pt: McGePoint3d);
	/**
	 * 获取或设置角度标注第二个参考线的结束点
	 * @returns 角度标注第二个参考线的结束点
	 */
	get xLine2End(): McGePoint3d;
	set xLine2End(pt: McGePoint3d);
	/**
	 * 通过参数计算角度标注
	 * @param dAngleVertexX 角度向量X轴值
	 * @param dAngleVertexY 角度向量Y轴值
	 * @param dFirstEndPointX 标注线1结束点X轴值
	 * @param dFirstEndPointY 标注线1结束点Y轴值
	 * @param dSecondEndPointX 标注线2结束点X轴值
	 * @param dSecondEndPointY 标注线2结束点Y轴值
	 * @param dTextPointX 标注文字X轴值
	 * @param dTextPointY 标注文字Y轴值
	 * @returns 返回布尔值
	 * @example
	 * ```ts
	   import { McDb2LineAngularDimension } from "mxcad";

	   const dimension = new McDb2LineAngularDimension()
	   // 设置计算维度所需的参数
	   const dAngleVertexX = 0;
	   const dAngleVertexY = 0;
	   const dFirstEndPointX = 1;
	   const dFirstEndPointY = 2;
	   const dSecondEndPointX = 3;
	   const dSecondEndPointY = 4;
	   const dTextPointX = 5;
	   const dTextPointY = 6;

	   // 调用 compute 方法计算维度
	   const result = dimension.compute(
		   dAngleVertexX,
		   dAngleVertexY,
		   dFirstEndPointX,
		   dFirstEndPointY,
		   dSecondEndPointX,
		   dSecondEndPointY,
		   dTextPointX,
		   dTextPointY
	   );
	   if (result) {
		   console.log("计算成功");
	   } else {
		   console.error("计算失败");
		}
	 * ```
	 */
	compute(dAngleVertexX: number, dAngleVertexY: number, dFirstEndPointX: number, dFirstEndPointY: number, dSecondEndPointX: number, dSecondEndPointY: number, dTextPointX: number, dTextPointY: number): boolean;
}
/**
 * 表示径向标注实体，用于标注圆弧或圆的半径。
 * @description
 * McDbRadialDimension 提供径向尺寸标注能力，支持设置中心点、引线长度和角度参数。
 * 它可以生成指向圆心的半径标注线，并用于显示圆或圆弧的半径尺寸。
 * 使用方法:
 * 1. 创建 McDbRadialDimension 实例并设置 center、chordPoint、leaderLength 等参数。
 * 2. 调用 compute()，将目标实体和拾取点传入。
 * 3. 将生成的标注对象添加到绘图上下文中进行显示。
 * @example
 * ```ts
 * // 绘制半径标注尺寸
 * import { MxCpp, MxCADResbuf, DxfCode, MxCADUiPrEntity, McDbRadialDimension, MxCADUiPrPoint } from "mxcad";
	async function _DrawRadialDimension() {
		const mxcad = MxCpp.getCurrentMxCAD()
		const getEnt = new MxCADUiPrEntity();
		getEnt.setFilter(new MxCADResbuf([DxfCode.kEntityType, "ARC,CIRCLE"]));
		getEnt.setMessage(t("选择圆弧或者圆"))
		const entId = await getEnt.go()
		if (entId.isNull()) return;
		const ent = entId.getMcDbEntity();
		if(!ent) return;

		let pick_pt = getEnt.pickPoint();

		let dim = new McDbRadialDimension();
		dim.dimensionStyle = mxcad.database.getCurrentlyDimStyleId();
		dim.compute(ent,pick_pt);

		let getPoint = new MxCADUiPrPoint();
		getPoint.setUserDraw((currentPoint,pWorldDraw)=>{
			dim.compute(ent,currentPoint);
			pWorldDraw.drawMcDbEntity(dim,true);
		});
		if(!await getPoint.go() ) return;
		mxcad.drawEntity(dim);
	}
 * ```
 * */
export declare class McDbRadialDimension extends McDbDimension {
	/**
	 * 构造函数
	 * @param imp 内部实现对象
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置被标注的圆弧中心点
	 */
	get center(): McGePoint3d;
	set center(pt: McGePoint3d);
	/**
	 * 获取或设置标注在圆弧弧上的位置。
	 */
	get chordPoint(): McGePoint3d;
	set chordPoint(pt: McGePoint3d);
	/**
	 * 标注引线长度
	 * @returns 标注引线长度
	 */
	get leaderLength(): number;
	/**
	* 设置标注引线长度
	* @param val 标注引线长度
	*/
	set leaderLength(val: number);
	/**
	* 标注圆弧的开始角
	*/
	get extArcStartAngle(): number;
	/**
	* 标注圆弧的开始角
	*/
	set extArcStartAngle(val: number);
	/**
	* 标注圆弧的结束角
	*/
	get extArcEndAngle(): number;
	/**
	* 标注圆弧的结束角
	*/
	set extArcEndAngle(val: number);
	/**
	* 依据被标注的对象，和标注点，计算标注参数。
	*/
	compute(ent: McDbEntity, pickPoint: McGePoint3d): boolean;
}
/**
 * 表示直径标注实体，用于标注圆弧或圆的直径。
 * @description
 * McDbDiametricDimension 提供直径尺寸标注能力，通过 chordPoint 和 farChordPoint 定义直径两端点，并支持引线长度与角度参数。
 * 它可以生成横穿圆心的直径尺寸标注，适用于圆、圆弧及其他圆形曲线的直径标注。
 * 使用方法:
 * 1. 创建 McDbDiametricDimension 实例并设置 chordPoint、farChordPoint 和 leaderLength。
 * 2. 调用 compute()，传入目标实体和拾取点。
 * 3. 将标注对象添加到当前绘图上下文进行显示。
 * @example
 * ```ts
 * // 绘制直径标注尺寸
 * import { MxCpp, MxCADResbuf, DxfCode, MxCADUiPrEntity, McDbRadialDimension, MxCADUiPrPoint } from "mxcad";
 *
	async function _DrawDiametricDimension() {
		const mxcad = MxCpp.getCurrentMxCAD()
		const getEnt = new MxCADUiPrEntity();
		getEnt.setFilter(new MxCADResbuf([DxfCode.kEntityType, "ARC,CIRCLE"]));
		getEnt.setMessage(t("选择圆弧或者圆"))
		const entId = await getEnt.go()
		if (entId.isNull()) return;
		const ent = entId.getMcDbEntity();
		if(!ent) return;

		let pick_pt = getEnt.pickPoint();

		let dim = new McDbDiametricDimension();
		dim.dimensionStyle = mxcad.database.getCurrentlyDimStyleId();
		dim.compute(ent,pick_pt);

		let getPoint = new MxCADUiPrPoint();
		getPoint.setUserDraw((currentPoint,pWorldDraw)=>{
			dim.compute(ent,currentPoint);
			pWorldDraw.drawMcDbEntity(dim,true);
		});
		if(!await getPoint.go() ) return;
		mxcad.drawEntity(dim);
	}
 * ```
 * */
export declare class McDbDiametricDimension extends McDbDimension {
	/**
	 * 构造函数
	 * @param imp 内部实现对象
	 */
	constructor(imp?: any);
	/**
	* 标注引线长度
	* @returns 标注引线长度
	*/
	get leaderLength(): number;
	/**
	* 设置标注引线长度
	* @param val 标注引线长度
	*/
	set leaderLength(val: number);
	/**
	 * 返回在被标注的曲线上的第二个点，这个点与chordPoint直径相对

	 */
	get farChordPoint(): McGePoint3d;
	set farChordPoint(pt: McGePoint3d);
	/**
	 * 返回在被标注的曲线上的第一个点

	 */
	get chordPoint(): McGePoint3d;
	set chordPoint(pt: McGePoint3d);
	/**
	* 标注圆弧的开始角
	*/
	get extArcStartAngle(): number;
	/**
	* 标注圆弧的开始角
	*/
	set extArcStartAngle(val: number);
	/**
	* 标注圆弧的结束角
	*/
	get extArcEndAngle(): number;
	/**
	* 标注圆弧的结束角
	*/
	set extArcEndAngle(val: number);
	/**
	* 依据被标注的对象，和标注点，计算标注参数。
	*/
	compute(ent: McDbEntity, pickPoint: McGePoint3d): boolean;
}
/**
 * 表示圆弧实体，用于绘制部分圆周曲线。
 * @description
 * McDbArc 封装一个圆弧对象，支持设置圆心、半径、起始角和结束角，能够绘制和计算圆弧几何。
 * 它适用于绘制部分圆周、创建圆弧对象或在图形上进行圆弧计算。
 * 使用方法:
 * 1. 创建 McDbArc 实例。
 * 2. 设置 `center`、`radius`、`startAngle` 和 `endAngle`。
 * 3. 在绘图上下文中显示该圆弧。
 * @example
 * ```ts
   import { McDbArc, MxCpp } from "mxcad"
   // 绘制圆弧
   const arc = new McDbArc() // 构造新圆弧对象
   arc.center = new McGePoint3d(0,0,0) // 设置圆弧圆心
   arc.radius = 20 // 设置圆弧半径
   arc.startAngle = Math.PI / 2 // 设置圆弧开始角度
   arc.endAngle = Math.PI * 3 / 2 // 设置圆弧结束角度
   arc.trueColor = new McCmColor(255, 233, 0) // 设置圆弧颜色
   MxCpp.getCurrentMxCAD().drawEntity(arc) // 绘制圆弧
 * ```
 */
export declare class McDbArc extends McDbCurve {
	/**
	 * 构造函数。
	 * @param imp 内部对象。
	 */
	constructor(imp?: any);
	/**
	 * 设置圆心坐标。
	 * @param x 圆心 x 坐标。
	 * @param y 圆心 y 坐标。
	 * @param z 圆心 z 坐标。
	 */
	setCenter(x: number, y: number, z?: number): void;
	/**
	 * 获取圆心坐标。
	 */
	get center(): McGePoint3d;
	/**
	 * 设置圆心坐标。
	 * @param pt 圆心坐标。
	 */
	set center(pt: McGePoint3d);
	/**
	 * 获取圆半径。
	 */
	get radius(): number;
	/**
	 * 设置圆半径。
	 * @param r 圆半径。
	 */
	set radius(r: number);
	/**
	 * 获取开始角度。
	 */
	get startAngle(): number;
	/**
	 * 设置开始角度。
	 * @param r 角度Math.PI。
	 */
	set startAngle(r: number);
	/**
	 * 获取结束角度。
	 */
	get endAngle(): number;
	/**
	 * 设置结束角度。
	 * @param r 角度Math.PI。
	 */
	set endAngle(r: number);
	/**
	 * 3点计算圆弧
	 * @example
	 * ```ts
	 * import { McDbArc, McGePoint3d, MxCpp } from "mxcad";
	 *
	 * const arc = new McDbArc();
	 * const pt1 = new McGePoint3d(20,0,0);
	 * const pt2 = new McGePoint3d(0,20,0);
	 * const pt3 = new McGePoint3d(-20,0,0);
	 * arc.computeArc(pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y);
	 * MxCpp.getCurrentMxCAD().drawEntity(arc)
	 * ```
	 */
	computeArc(dStartPointX: number, dStartPointY: number, dMidPointX: number, dMidPointY: number, dEndPointX: number, dEndPointY: number): boolean;
	/**
	 * 修正被镜向的圆弧
	 */
	correctMirror(): boolean;
}
/**
 * 表示椭圆或椭圆弧实体，用于绘制椭圆曲线。
 * @description
 * McDbEllipse 封装椭圆几何，支持设置中心、主轴、半径比以及可选的起止角。
 * 该类既可用于完整椭圆，也可用于椭圆弧绘制和几何计算。
 * 使用方法:
 * 1. 创建 McDbEllipse 实例。
 * 2. 设置 `center`、`majorAxis`、`radiusRatio`，并根据需要设置 `startAngle`、`endAngle`。
 * 3. 将椭圆实体添加到绘图上下文进行显示。
 * @example
 * ```ts
	import { McDbEllipse, MxCpp } from "mxcad"
	//绘制椭圆弧
	const ellipse_arc = new McDbEllipse() // 构造椭圆对象
	ellipse_arc.center = new McGePoint3d(-380, -200) // 设置对象圆心
	ellipse_arc.majorAxis = new McGeVector3d(0, 150, 0) // 设置对象主轴向量
	ellipse_arc.minorAxis = new McGeVector3d(280, 0, 0) // 设置对象副轴向量
	ellipse_arc.startAngle = Math.PI / 2 // 设置对象开始角度
	ellipse_arc.endAngle = Math.PI * 3 / 2 // 设置对象结束角度
	ellipse_arc.trueColor = new McCmColor(0, 255, 255) //设置对象颜色
	MxCpp.getCurrentMxCAD().drawEntity(ellipse_arc) // 绘制椭圆对象

	//绘制椭圆
	const ellipse = new McDbEllipse() // 构造椭圆对象
	ellipse.center = new McGePoint3d(-200, -200) // 设置对象圆心
	ellipse.majorAxis = new McGeVector3d(0, 300, 0) // 设置对象主轴向量
	ellipse.radiusRatio = 0.5 // 设置椭圆的副轴长度与主轴长度的比值
	ellipse.trueColor = new McCmColor(255, 233, 0) //设置对象颜色
	MxCpp.getCurrentMxCAD().drawEntity(ellipse) // 绘制椭圆对象
 * ```
 */
export declare class McDbEllipse extends McDbCurve {
	/**
	 * 构造函数。
	 * @param imp 内部对象。
	 */
	constructor(cenx?: object | number, ceny?: number, cenz?: number, majorAxisx?: number, majorAxisy?: number, majorAxisz?: number, radiusRatio?: number, startAngle?: number, endAngle?: number);
	/**
	 * 设置圆心坐标。
	 * @param x 圆心 x 坐标。
	 * @param y 圆心 y 坐标。
	 * @param z 圆心 z 坐标。
	 */
	setCenter(x: number, y: number, z?: number): void;
	/**
	 * 获取圆心坐标。
	 */
	get center(): McGePoint3d;
	/**
	 * 设置圆心坐标。
	 * @param pt 圆心坐标。
	 */
	set center(pt: McGePoint3d);
	/**
	 * 设置主轴向量
	 * @param x  x 坐标。
	 * @param y  y 坐标。
	 * @param z  z 坐标。
	 */
	setMajorAxis(x: number, y: number, z?: number): void;
	/**
	 * 获取主轴向量
	 */
	get majorAxis(): McGeVector3d;
	/**
	 * 设置主轴向量。
	 * @param vec 三维向量对象
	 */
	set majorAxis(pt: McGeVector3d);
	/**
	 * 设置副轴向量
	 * @param x  x 坐标。
	 * @param y  y 坐标。
	 * @param z  z 坐标。
	 */
	setMinorAxis(x: number, y: number, z?: number): void;
	/**
	 * 获取副轴向量
	 */
	get minorAxis(): McGeVector3d;
	/**
	 * 设置副轴向量。
	 */
	set minorAxis(pt: McGeVector3d);
	/**
	 * 获取椭圆的副轴长度与主轴长度的比值
	 */
	get radiusRatio(): number;
	/**
	 * 设置椭圆的副轴长度与主轴长度的比值
	 */
	set radiusRatio(val: number);
	/**
	 * 获取椭圆弧的开始角度
	 */
	get startAngle(): number;
	/**
	 * 设置椭圆弧的开始角度
	 */
	set startAngle(val: number);
	/**
	 * 获取椭圆弧的结束角度
	 */
	get endAngle(): number;
	/**
	 * 设置椭圆弧的结束角度
	 */
	set endAngle(val: number);
}
/**
 * McDbPoint表示图纸中的单个点实体。
 * @description
 * McDbPoint 包含一个具有明确世界坐标和外观控制的点对象。
 * 支持设置位置，并可将该点用作可绘制的 CAD 实体，用于尺寸标注、捕捉点或简单的图形参考。*
 * 使用方法：
 * 1. 创建一个新的 McDbPoint。
 * 2. 设置其位置以及可选的显示属性，例如 trueColor。
 * 3. 使用当前 MxCAD 上下文绘制该点。
 * @example
 * ```ts
 * //绘制一个点对象
	import { McDbPoint } from "mxcad"

	const point = new McDbPoint() // 构造一个点对象
	const color = new McCmColor(0,255,0)
	point.trueColor = color // 设置点对象颜色
	point.setPosition(0, 0) // 设置点对象位置
	MxCpp.getCurrentMxCAD().drawEntity(point) // 绘制点对象
 * ```
 */
export declare class McDbPoint extends McDbEntity {
	/**
	 * 构造函数。
	 * @param imp 内部对象。
	 * @example
	 * ```ts
	 * import { McDbPoint, McGePoint3d } from "mxcad";
	 *
	 * const pt1 = new McDbPoint(0,0,0);
	 *
	 * const point = new McGePoint3d(10,10,0);
	 * const pt2 = new McDbPoint(point);
	 * ```
	 */
	constructor(x?: object | number, y?: number, z?: number);
	/**
	 * 设置点坐标。
	 * @param x X坐标
	 * @param y Y坐标
	 * @param z Z坐标
	 */
	setPosition(x: number, y: number, z?: number): void;
	/**
	 * 获取点坐标。
	 */
	get position(): McGePoint3d;
	/**
	 * 设置点坐标。
	 */
	set position(pt: McGePoint3d);
}
/**
 * 表示一种用于用实色或图案填充封闭区域的 hatch 实体。
 * @description
 * McDbHatch 提供了基于图案定义、颜色控制以及边界循环检查的区域填充功能。
 * 可从闭合区域创建，配置自定义图案参数，并以填充实体形式绘制。*
 * 使用方法：
 * 1. 创建或获取一个用于封闭可填充区域的 McDbHatch 实例。
 * 2. 清除或定义填充图案，并设置所需的图案或颜色。
 * 3. 绘制填充实体，或将其实体保存为图纸数据库的一部分。
 * @example
 * ```ts
   import { MxCADUiPrPoint, MxCADUtility, McDbHatch, MxCpp, McDb, McCmColor} from "mxcad"
   //选点填充
	const getPoint = new MxCADUiPrPoint();
	console.log("\n指定填充区域内部一点:");
	let pt = (await getPoint.go()) as McGePoint3d;
	if (!pt) return;

	let hatch:McDbHatch = MxCADUtility.builderHatchFromPoint(pt);
	if (!hatch) {
		console.log("没有找到闭合区域\n")
		return;
	}
	// 清除填充图案效果
	hatch.clearPatternDefinition();
	// 添加图案填充定义
	hatch.addPatternDefinition(45, 1, 1, 1, 0.25, [45, 0.17677695, 0, 0, 0.25, 0.125, -0.0625])
	// 设置填充图案
	hatch.setPattern(McDb.HatchPatternType.kCustomDefined, 'test')
	// 设置填充颜色
	hatch.trueColor = new McCmColor(0, 133, 122)
	// 绘制填充对象
	MxCpp.getCurrentMxCAD().drawEntity(hatch);
 * ```
 */
export declare class McDbHatch extends McDbEntity {
	/**
	 * 构造函数。
	 * @param imp 内部对象。
	 */
	constructor(x?: object);
	/**
	 * 闭合区域次数
	 */
	get numLoops(): number;
	/**
	 * 某次闭合区域索引中的类型
	 */
	loopTypeAt(loopIndex: number): number;
	/** 获取索引的值
	 * @param loopIndex  index 闭合区域的索引
	 * @returns { Object } ret 是否成功获取 | lootype 类型 | vertices 坐标集合 | bulges凸度集合
	 *  */
	getLoopAt(loopIndex: number): {
		ret: boolean;
		lootype: number;
		vertices: McGePoint3d[];
		bulges: number[];
	};
	/**
	 * 填充图案类型
	 */
	patternType(): number;
	/**
	 * 填充图案名称
	 */
	patternName(): string;
	/**
	 * 设置填充图案
	 * @param type 填充图案的来源类型
	 * @param patName 填充图案名称
	 */
	setPattern(type: number, patName: string): void;
	/**
	 * 获取填充图案角度
	 */
	get patternAngle(): number;
	/**
	 * 设置填充图案角度
	 */
	set patternAngle(angle: number);
	/**
	 * 获取填充图案缩放比例
	 */
	get patternScale(): number;
	/**
	 * 设置填充图案缩放比例
	 */
	set patternScale(scale: number);
	/**
	 * 获取填充图案空间
	 */
	get patternSpace(): number;
	/**
	 * 设置填充图案空间
	 */
	set patternSpace(space: number);
	/**
	 * 获取填充图案是否是双倍
	 */
	get patternDouble(): boolean;
	/**
	 * 设置填充图案是否为双倍
	 * @param isDouble 是否双倍
	 */
	set patternDouble(isDouble: boolean);
	/**
	 * 图案定义的数量
	 */
	get numPatternDefinitions(): number;
	/** 获取对应图案定义的数据
	 * @param index 索引
	 * @returns { Object } ret 是否成功获取 | angle 角度 | baseX, baseY 基点位置 | offsetX, offsetY 偏移位置 | aryDashes 短划线数据
	 */
	getPatternDefinitionAt(index: number): {
		ret: boolean;
		angle: number;
		baseX: number;
		baseY: number;
		offsetX: number;
		offsetY: number;
		aryDashes: number[];
	};
	/** 添加图案定义
	 * @param angle 角度 如 45
	 * @param baseX 基点x坐标
	 * @param baseY 基点y坐标
	 * @param offsetX 偏移x坐标
	 * @param offsetY 偏移y坐标
	 * @param dashes 短划线数据
	 * @returns { Boolean } 是否成功添加图案定义
	 *  */
	addPatternDefinition(angle: number, baseX: number, baseY: number, offsetX: number, offsetY: number, dashes: number[]): boolean;
	/**
	 * 清空图案定义
	 */
	clearPatternDefinition(): boolean;
	/**
	 * 填充样式
	 */
	hatchStyle(): McDb.HatchStyle;
	/**
	 * 设置填充样式
	 */
	setHatchStyle(val: McDb.HatchStyle): void;
	/** 追加闭合区域
	 * @param loopType 闭合区域类型
	 * @param vertices 坐标集合
	 * @param bulges 凸度集合
	 * @return 返回追加结果
	 */
	appendLoop(vertices: McGePoint3dArray, bulges?: number[], loopType?: number): boolean;
	/**
	 * 追加圆构造的闭合区域
	 * @param dCenX 圆心X轴坐标
	 * @param dCenY 圆心Y轴坐标
	 * @param dR 圆半径
	 * @param dPrecision 精度参数，默认值为 0。
	 * @param loopType 循环类型参数，默认值为 McDb.HatchLoopType.kPolyline
	 * @return 追加结果
	 */
	appendCircleLoop(dCenX: number, dCenY: number, dR: number, dPrecision?: number, loopType?: number): any;
	/**
	 * 删除某个索引下的闭合区域
	 * @param loopIndex 移除的循环的索引
	 */
	removeLoopAt(loopIndex: number): boolean;
	/**
	 * 删除所有闭合区域
	 */
	removeAllLoop(): boolean;
	/** 设置某个索引下的闭合区域数据
	 * @param loopIndex 闭合区域索引
	 * @param loopType 闭合区域类型
	 * @param vertices 坐标集合
	 * @param bulges 凸度集合
	 */
	setLoopAt(loopIndex: number, vertices: McGePoint3dArray, bulges: number[], loopType?: number): boolean;
	/**
	 * 检查填充对象是否为实体填充
	 * @returns 布尔值
	 */
	isSolid(): boolean;
	/**
	 * 对当前定义的填充图案数据进行缩放。
	 * @param scale 缩放倍数
	 */
	scalePattern(scale: number): boolean;
	/**
	 *通过当前的图案比例，图案定义，角度数据，重新计算图案定义数据。
	 *计算后，图案比例，角度属性已经计算到图案定义数据中，图案比例，角度属性被重置为0，图案比例被重置为1.
	 */
	computePatternDefinition(): boolean;
}
/**
 * McDbProxyEntity 是代理实体类，用于表示存储在外部源中的特殊实体对象。
 *
 * @description
 * 该类用于处理 CAD 中的代理实体，通常用于访问位于外部文件或数据库中的原始对象信息。
 *
 * 它可以读取代理实体中的文字内容和原始实体 ID，适合对特殊格式或外部数据源对象进行识别和提取。
 *
 * 使用方法总结：
 * 1. 先获取 McDbProxyEntity 对象。
 * 2. 再读取其文本内容或原始实体 ID。
 * 3. 最后根据业务需要对代理实体进行解析、筛选或后续处理。
 *
 * @example
 * ```ts
 * //遍历代理实体中的文字
 * import { MxCADSelectionSet, McDbProxyEntity } from "mxcad";
 *
 * let ss = new MxCADSelectionSet();// 构造选择集对象
 * // 设置过滤器
 * let filter = new MxCADResbuf();
 * filter.AddMcDbEntityTypes("TEXT,MTEXT,INSERT,ACAD_PROXY_ENTITY");
 * ss.allSelect(filter);// 筛选图纸上所有的文本、图块、代理实体对象
 * // 遍历选择对象
 * ss.forEach((id,item)=>{
 * const ent = id.getMcDbEntity();
 * if(ent instanceof McDbProxyEntity){
 *    let proxyEntity: McDbProxyEntity = ent;
 *    let aryText = proxyEntity.getAllTextContent();
 *    aryText.forEach((val)=>{
 *      console.log("遍历文字", val);
 *    });
 * })
 * ```
 */
export declare class McDbProxyEntity extends McDbEntity {
	/**
	* 构造函数。
	* @param imp 内部对象。
	*/
	constructor(x?: object);
	/**
	 * 获取代理实体中所有的文本内容
	 * @return 文本数组
	 */
	getAllTextContent(): McGeStringArray;
	/**
	 * 获取代理实体的所有原始实体ID
	 * @return 对象ID数组
	 */
	getAllEntityIds(): McObjectId[];
	/**
	 * 获取代理实体的原始类名。
	 * @return 原始类名
	 */
	getOriginalClassName(): string;
}
/**
 * McDbRasterImage 是光栅图片实体类，用于在 CAD 中显示位图图像。
 *
 * @description
 * 该类用于插入和管理光栅图像对象，支持设置图像定义 ID、显示尺寸、方向和裁剪边界。
 *
 * 它适合在绘图中嵌入外部图片资源，并根据需要控制图像的位置、缩放和裁剪效果。
 *
 * 使用方法总结：
 * 1. 先创建 McDbRasterImage 实例。
 * 2. 再设置图像定义 ID、显示尺寸、方向和裁剪边界。
 * 3. 最后将其绘制到当前空间中。
 *
 * @example
 * ```ts
 * import { MxCpp, McGePoint3d, McDbRasterImage, McGeVector3d } from "mxcad";
 *
 * //画图片
 * function drawImg() {
 *     const mxcad = MxCpp.getCurrentMxCAD();
 *     mxcad.newFile();
 *     let imagUrl = "https://cdn.pixabay.com/photo/2022/11/15/12/23/winter-7593872_960_720.jpg";
 *     mxcad.loadImage(imagUrl, (image) => {
 *         if (!image) {
 *             console.log("loadImage failed");
 *             return;
 *         }
 *         let width = mxcad.mxdraw.viewCoordLong2Cad(100);
 *         let height = (image.height / image.width) * width;
 *         const id = mxcad.addImageDefine(imagUrl, "winter-7593872_960_720.jpg", true);
 *         const img = new McDbRasterImage();
 *         img.setImageDefId(id);
 *         img.setDwgImageSize(image.width, image.height);
 *         const origin = new McGePoint3d(0, 0, 0);
 *         const uCorner = McGeVector3d.kXAxis.clone();
 *         uCorner.mult(width);
 *         const vOnPlane = McGeVector3d.kYAxis.clone();
 *         vOnPlane.mult(height);
 *         img.setOrientation(origin, uCorner, vOnPlane);
 *         mxcad.drawEntity(img);
 *         mxcad.updateDisplay();
 *     });
 * };
 * ```
 */
export declare class McDbRasterImage extends McDbEntity {
	/**
	* 构造函数。
	* @param imp 内部对象。
	*/
	constructor(x?: object);
	/**
	 * 设置或获取图像的方向
	 * @param origin 原点
	 * @param uCorner 沿X轴的向量
	 * @param vOnPlane 沿Y轴的向量
	 * @returns 返回一个布尔值，指示设置是否成功
	 * @example
	 * ```ts
	 * import { McDbRasterImage, McGePoint3d, McGeVector3d } from "mxcad";
	 *
	 * const rasterImage = new McDbRasterImage();
	 * const origin = new McGePoint3d(0, 0, 0);
	 * const uCorner = McGeVector3d.kXAxis.clone();
	 * const vOnPlane = McGeVector3d.kYAxis.clone();
	 * const isSuccess = rasterImage.setOrientation(origin, uCorner, vOnPlane);
	 * if(isSuccess){
	 *   // 设置失败
	 * }else{
	 *   //设置成功
	 * }
	 * ```
	 */
	setOrientation(origin: McGePoint3d, uCorner: McGeVector3d, vOnPlane: McGeVector3d): boolean;
	/**
	 * 获取图像的方向
	 * @returns { object } origin: 原点 | uCorner: 沿X轴的向量 | vOnPlane: 沿Y轴的向量
	 * @example
	 * ```ts
	 * //假设 rasterImage 为光栅图片实例
	 * const orientation = rasterImage.getOrientation();
	 * console.log(orientation.origin); // 输出原点
	 * console.log(orientation.uCorner); // 输出沿X轴的向量
	 * console.log(orientation.vOnPlane); // 输出沿Y轴的向量
	 * ```
	 */
	getOrientation(): {
		origin: McGePoint3d;
		uCorner: McGeVector3d;
		vOnPlane: McGeVector3d;
	};
	/**
	 * 设置保存dwg文件时，图片的宽高像素。
	 */
	setDwgImageSize(width: number, height: number): boolean;
	/**
	 * 返回dwg文件中的图片的宽高像素。
	 */
	getDwgImageSize(): number[];
	/**
	 * 设置图像的定义ID
	 * @param imageId 图像的定义 ID
	 * @example
	 * ```ts
	 * import { MxCpp, } from "mxcad";
	 *
	 * // 插入图片
		function Mx_Test_ModifyImage() {
			if (!idImage) return;
			let mxcad = MxCpp.getCurrentMxCAD();
			let imagUrl = "https://cdn.pixabay.com/photo/2022/11/15/12/23/winter-7593872_960_720.jpg";
			mxcad.loadImage(imagUrl, (imagedata) => {
				if (!imagedata) {
					console.log("loadImage failed");
					return;
				}
				let imagedefid = mxcad.addImageDefine(imagUrl, "winter-7593872_960_720.jpg", true);
				let image = idImage.getMcDbEntity() as McDbRasterImage;
				if (image) {
					image.setImageDefId(imagedefid);
				}
				mxcad.updateDisplay();
			});
		}
	 * ```
	 */
	setImageDefId(imageId: McObjectId): void;
	/**
	 * 获取图像的定义ID
	 */
	imageDefId(): McObjectId;
	/**
	 * 设置图像对象的裁剪边界
	 * @param type 裁剪边界的类型
	 * @param aryPoint 裁剪边界点数组
	 * @return 返回一个布尔值，指示设置是否成功。
	 * @example
	 * ```ts
	 * // 图片裁剪
		import { MxCpp, McGePoint3d, McDb, McGePoint3dArray, McDbCircle, McDbPolyline, McDbRasterImage } from "mxcad";

		//画图片
		function drawImg() {
			const mxcad = MxCpp.getCurrentMxCAD();
			// 创建新画布
			mxcad.newFile();
			
			//图片插入点
			const pt = new McGePoint3d(0, 0, 0)
			//图片地址
			let imagUrl = "https://cdn.pixabay.com/photo/2022/11/15/12/23/winter-7593872_960_720.jpg";
			mxcad.loadImage(imagUrl, (image) => {
				if (!image) {
					console.log("loadImage failed");
					return;
				}
				let width = mxcad.mxdraw.viewCoordLong2Cad(100);
				let height = (image.height / image.width) * width;
				const id = mxcad.drawImage((pt as any).x, (pt as any).y, width, height, 0, imagUrl, true, image.width, image.height);
				const ent = id.getMcDbEntity() as McDbRasterImage;
				const { minPt, maxPt } = ent.getBoundingBox()
				const insertPt = minPt.clone().addvec(maxPt.sub(minPt).mult(1 / 2))
				// 设置一个圆做它的剪切边界.
				let dR = maxPt.x = minPt.y;
				if (dR < (maxPt.y - minPt.y)) dR = maxPt.y - minPt.y;
				dR *= 0.3;
				let circle = new McDbCircle(insertPt.x, insertPt.y, 0, dR);
				let samplePoints = circle.getSamplePoints(dR * 0.00001);
				let aryPoint = new McGePoint3dArray();

				samplePoints.forEach((val, _type, dxf) => {
					if (dxf === 1010) {
						const point = new McGePoint3d(val.x, val.y, val.z)
						aryPoint.append(point);
					}
				});
				ent.setClipBoundary(McDb.ClipBoundaryType.kPoly, aryPoint, true);
				ent.setClip(true);
				mxcad.drawEntity(circle);
				mxcad.updateDisplay();
			});
		};
	 * ```
	 */
	setClipBoundary(type: McDb.ClipBoundaryType, aryPoint: McGePoint3dArray, isWroldCoords?: boolean): boolean;
	/**
	 * 图片是否使用剪切边界
	 */
	isClip(): boolean;
	/**
	* 设置图片使用剪切边界
	*/
	setClip(isClip: boolean): void;
	/**
	 * 获取图像对象的裁剪边界
	 */
	clipBoundary(): McGePoint3dArray;
	/**
	 * 获取裁剪边界的类型
	 */
	clipBoundaryType(): McDb.ClipBoundaryType;
}
/**
 * McDbWipeout 是 wipeout 实体类，用于在图纸中创建遮挡区域对象。
 *
 * @description
 * 该类用于生成遮挡对象，可用于覆盖图形显示区域，常用于隐藏背景或局部区域内容。
 *
 * 使用方法总结：
 * 1. 先创建 McDbWipeout 对象。
 * 2. 再设置其边界顶点和遮挡区域。
 * 3. 最后将其加入当前空间并显示遮挡效果。
 *
 * @example
 * ```ts
 * import { McDbWipeout, McGePoint3dArray, MxCpp } from "mxcad";
 *
 * const wipeout = new McDbWipeout();
 * const points = new McGePoint3dArray();
 * points.append(new McGePoint3d(0, 0, 0));
 * points.append(new McGePoint3d(100, 0, 0));
 * points.append(new McGePoint3d(100, 100, 0));
 * points.append(new McGePoint3d(0, 100, 0));
 * wipeout.setVertices(points);
 * MxCpp.getCurrentMxCAD().drawEntity(wipeout);
 * ```
 */
export declare class McDbWipeout extends McDbEntity {
	/**
	* 构造函数。
	*/
	constructor(x?: object);
	/**
	 * 设置Wipeout类边界
	 */
	setVertices(aryPoint: McGePoint3dArray): boolean;
	/**
	 * 获取Wipeout类边界

	 */
	getVertices(): McGePoint3dArray;
}
/**
 * McDbBackgroundEntity 是背景绘制对象类，用于管理背景图形的显示状态。
 *
 * @description
 * 该类用于控制背景对象的显示与隐藏，并可根据外部 DWG 文件切换背景内容。
 *
 * 使用方法总结：
 * 1. 先创建 McDbBackgroundEntity 对象。
 * 2. 再绑定目标 DWG 文件并设置显示状态。
 * 3. 最后通过显示或清理操作控制背景内容的呈现。
 *
 * @example
 * ```ts
 * import { McDbBackgroundEntity } from "mxcad";
 *
 * const background = new McDbBackgroundEntity({} as any);
 * background.setShow("sample.dwg", true);
 * ```
 */
export declare class McDbBackgroundEntity extends McDbEntity {
	constructor(x: object);
	/**
	* 设置是否显示背景对象
	*/
	setShow(sDwgFile: string, isShow: boolean): boolean;
	/**
	* 是否显示背景对象
	*/
	isShow(sDwgFile: string): boolean;
	/**
	* 显示背景时使用指定颜色替换显示
	*/
	setShowColor(sDwgFile: string, lColor: number): boolean;
	/**
	* 返回背景显示使用的数据库对象.
	*/
	getBackgroundDatabase(sDwgFile: string): McDbDatabase | null;
	/**
	* 清空所有背景显示
	*/
	clearAll(): boolean;
	/**
	* 清空背景显示
	*/
	clearDwg(sDwgFile: string): boolean;
}
/**
 * McDbSpline 是样条线实体类，用于创建和编辑 NURBS 样条曲线。
 *
 * @description
 * 该类用于表示 CAD 中的样条曲线对象，支持设置控制点、节点、权重和拟合点等数据。
 *
 * 它适合构建平滑连续的曲线形状，并进行样条数据的读取与修改。
 *
 * 使用方法总结：
 * 1. 先创建 McDbSpline 实例。
 * 2. 再设置控制点、节点、权重或拟合点数据。
 * 3. 最后将样条曲线绘制到当前空间中。
 *
 * @example
 * ```ts
 * import { McDbSpline, McGePoint3dArray, MxCpp } from "mxcad";
 *
 * const spline = new McDbSpline();
 * const points = new McGePoint3dArray();
 * points.append(new McGePoint3d(0, 0, 0));
 * points.append(new McGePoint3d(10, 20, 0));
 * points.append(new McGePoint3d(20, 0, 0));
 * spline.setFitPoints({
 *     degree: 3,
 *     fitTolerance: 0.01,
 *     tangentsExist: false,
 *     startTangent: new McGeVector3d(1, 0, 0),
 *     endTangent: new McGeVector3d(1, 0, 0),
 *     fitPoints: points
 * });
 * MxCpp.getCurrentMxCAD().drawEntity(spline);
 * ```
 */
export declare class McDbSpline extends McDbCurve {
	/**
	 * 构造函数
	 * @param imp 实现对象
	 * @example
	 * ```
	 */
	constructor(imp?: any);
	/**
	 * 得到样条线的数据.
	 * @example
	 */
	getNurbsData(): {
		degree: number;
		rational: boolean;
		closed: boolean;
		periodic: boolean;
		controlPoints: McGePoint3dArray;
		knots: McGeDoubleArray;
		weights: McGeDoubleArray;
		controlPtTol: number;
		knotTol: number;
	};
	/**
	 * 设置样条线的数据.
	 * @example
	 *
	 */
	setNurbsData(data: {
		degree: number;
		rational: boolean;
		closed: boolean;
		periodic: boolean;
		controlPoints: McGePoint3dArray;
		knots: McGeDoubleArray;
		weights: McGeDoubleArray;
		controlPtTol: number;
		knotTol: number;
	}): boolean;
	/**
	 * 得到样条线的拟合数据.
	 * @example
	 */
	getFitPoints(): {
		degree: number;
		fitTolerance: number;
		tangentsExist: boolean;
		startTangent: McGeVector3d;
		endTangent: McGeVector3d;
		fitPoints: McGePoint3dArray;
	};
	/**
	 *设置样条线的拟合数据.
	 * @example
	 */
	setFitPoints(data: {
		degree: number;
		fitTolerance: number;
		tangentsExist: boolean;
		startTangent: McGeVector3d;
		endTangent: McGeVector3d;
		fitPoints: McGePoint3dArray;
	}): boolean;
}
/**
 * McDbXline 是构造线对象类，用于创建无限延伸的构造线。
 *
 * @description
 * 该类用于在图纸中创建一条从基点出发沿指定方向无限延伸的构造线，常用于辅助绘图和定位参考。
 *
 * 使用方法总结：
 * 1. 先创建 McDbXline 实例。
 * 2. 再设置其基点和方向向量。
 * 3. 最后将构造线绘制到当前空间中。
 *
 * @example
 * ```ts
 * import { McDbXline, McGePoint3d, McGeVector3d, MxCpp } from "mxcad";
 *
 * const xline = new McDbXline();
 * xline.basePoint = new McGePoint3d(0, 0, 0);
 * xline.unitDir = new McGeVector3d(1, 1, 0);
 * MxCpp.getCurrentMxCAD().drawEntity(xline);
 * ```
 */
export declare class McDbXline extends McDbCurve {
	/**
	 * 构造函数。
	 * @param imp 内部对象。

	 */
	constructor(imp?: any);
	/**
	 * 设置点坐标。
	 * @param x X坐标
	 * @param y Y坐标
	 * @param z Z坐标

	 */
	setBasePoint(x: number, y: number, z?: number): void;
	/**
	 * 设置点坐标。
	 * @param x X坐标
	 * @param y Y坐标
	 * @param z Z坐标

	 */
	set basePoint(pt: McGePoint3d);
	/**
	 * 获取点坐标。

	 */
	get basePoint(): McGePoint3d;
	/**
	 * 设置射线的方向向量
	 * @param x X坐标
	 * @param y Y坐标
	 * @param z Z坐标

	 */
	setUnitDir(x: number, y: number, z?: number): void;
	/**
	* 设置射线的方向向量
	* @param x X坐标
	* @param y Y坐标
	* @param z Z坐标

	*/
	set unitDir(vec: McGeVector3d);
	/**
	 * 获取射线的方向向量。

	 */
	get unitDir(): McGeVector3d;
}
/**
 * McDbRay 是射线对象类，用于创建从基点向指定方向延伸的射线。
 *
 * @description
 * 该类用于表示 CAD 中的一条射线，常用于辅助定位、测量和构造几何关系。
 *
 * 使用方法总结：
 * 1. 先创建 McDbRay 实例。
 * 2. 再设置其基点和方向向量。
 * 3. 最后将射线绘制到当前空间中。
 *
 * @example
 * ```ts
 * import { McDbRay, McGePoint3d, McGeVector3d, MxCpp } from "mxcad";
 *
 * const ray = new McDbRay();
 * ray.basePoint = new McGePoint3d(0, 0, 0);
 * ray.unitDir = new McGeVector3d(1, 0, 0);
 * MxCpp.getCurrentMxCAD().drawEntity(ray);
 * ```
 */
export declare class McDbRay extends McDbCurve {
	/**
	 * 构造函数。
	 * @param imp 内部对象。
	 */
	constructor(imp?: any);
	/**
	 * 设置点坐标。
	 * @param x X坐标
	 * @param y Y坐标
	 * @param z Z坐标
	 */
	setBasePoint(x: number, y: number, z?: number): void;
	/**
	 * 设置点坐标。
	 * @param x X坐标
	 * @param y Y坐标
	 * @param z Z坐标
	 */
	set basePoint(pt: McGePoint3d);
	/**
	 * 获取点坐标。
	 */
	get basePoint(): McGePoint3d;
	/**
	 * 设置射线的方向向量
	 * @param x X坐标
	 * @param y Y坐标
	 * @param z Z坐标
	 */
	setUnitDir(x: number, y: number, z?: number): void;
	/**
	* 设置射线的方向向量
	* @param x X坐标
	* @param y Y坐标
	* @param z Z坐标
	*/
	set unitDir(vec: McGeVector3d);
	/**
	 * 获取射线的方向向量。
	 */
	get unitDir(): McGeVector3d;
}
/**
 * McDbMxRegion 是面域对象类，用于创建和操作二维面域几何。
 *
 * @description
 * 该类用于表示 CAD 中的面域对象，可通过边界轮廓进行创建，并支持布尔运算、偏移和三角化等操作。
 *
 * 使用方法总结：
 * 1. 先创建 McDbMxRegion 实例。
 * 2. 再添加轮廓边界并设置必要的几何参数。
 * 3. 最后根据需要执行布尔运算、偏移或三角化处理。
 *
 * @example
 * ```ts
 * import { McDbMxRegion, McGePoint3dArray, MxCpp } from "mxcad";
 *
 * const region = new McDbMxRegion();
 * const points = new McGePoint3dArray();
 * points.append(new McGePoint3d(0, 0, 0));
 * points.append(new McGePoint3d(10, 0, 0));
 * points.append(new McGePoint3d(10, 10, 0));
 * points.append(new McGePoint3d(0, 10, 0));
 * region.addContour(points);
 * MxCpp.getCurrentMxCAD().drawEntity(region);
 * ```
 */
export declare class McDbMxRegion extends McDbEntity {
	/**
	 * 构造函数。
	 * @param imp 内部对象。
	 */
	constructor(imp?: any);
	/**
	 * 得到面域的边界数目
	 */
	getContourCount(): number;
	/**
	 * 得到面域的边界坐标
	 */
	getContour(index: number): McGePoint3dArray;
	/**
	 * 给面域添加边界坐标
	 */
	addContour(points: McGePoint3dArray): boolean;
	/**
	 * 从一个曲线对象数据给面域添加边界坐标

	 */
	addEntityContour(entity: McDbEntity, approxEps?: number): boolean;
	/**
	* 面域与面域之前进行bool运行

	*/
	booleanOption(type: McDb.BooleanOptionType, other: McDbMxRegion): McDbMxRegion[];
	/**
	* 偏移面域边界
	*/
	inflatePaths(delta: number, joinType?: number, endType?: number): McDbMxRegion;
	/**
	* 三角化面域
	*/
	triangulate(useDelaunay?: boolean): McDbMxRegion;
	/**
	* 面域数据是否为空
	*/
	isEmpty(): boolean;
	/**
	* 清除面域数据
	*/
	clearData(): boolean;
	/**
	* 从另一个面域数据拷贝数据
	*/
	copyData(fromRegion: McDbMxRegion): boolean;
}
/**
 * McDbViewport 是视口对象类，用于创建和管理布局视口。
 *
 * @description
 * 该类用于表示 CAD 中的视口对象，支持设置视口尺寸、中心位置和显示范围。
 *
 * 使用方法总结：
 * 1. 先创建 McDbViewport 实例。
 * 2. 再设置其宽度、高度和中心位置等参数。
 * 3. 最后将其应用到布局视口中进行显示。
 *
 * @example
 * ```ts
 * import { McDbViewport, MxCpp } from "mxcad";
 *
 * const viewport = new McDbViewport();
 * viewport.width = 100;
 * viewport.height = 50;
 * MxCpp.getCurrentMxCAD().drawEntity(viewport);
 * ```
 */
export declare class McDbViewport extends McDbEntity {
	/**
	* 构造函数。
	* @param imp 内部对象。
	*/
	constructor(x?: object);
	/**
	* 设置高度
	*/
	set height(val: number);
	/**
	 * 获取宽度
	 */
	get height(): number;
	/**
	* 设置宽度
	*/
	set width(val: number);
	/**
	 * 获取高度
	 */
	get width(): number;
	/**
	* 设置视口中心位置
	*/
	set centerPoint(vec: McGePoint3d);
	/**
	 * 获取视口中心位置
	 */
	get centerPoint(): McGePoint3d;
	/**
	* 设置视口目标位置
	*/
	set viewTarget(vec: McGePoint3d);
	/**
	 * 获取视口目标位置
	 */
	get viewTarget(): McGePoint3d;
	/**
	* 设置视口方向
	*/
	set viewDirection(vec: McGeVector3d);
	/**
	 * 获取视口方向
	 */
	get viewDirection(): McGeVector3d;
	/**
	* 设置可视高度
	*/
	set viewHeight(val: number);
	/**
	 * 获取可视高度
	 */
	get viewHeight(): number;
	/**
	 * 设置视口可视位置
	 */
	set viewCenter(vec: McGePoint3d);
	/**
	 * 获取视口可视位置
	 */
	get viewCenter(): McGePoint3d;
	/**
	* 设置可视区域旋转角度
	*/
	set twistAngle(val: number);
	/**
	 * 获取可视区域旋转角度
	 */
	get twistAngle(): number;
}
/**
 * Dxf组码
 * @public
 */
export declare enum DxfCode {
	/** 实体类型 */
	kEntityType = 5020,
	/** 实体图层 */
	kLayer = 8,
	/** 块名 */
	kBlockName = 2,
	/** 颜色 */
	kColor = 62,
	/** XData 类型 */
	kAppName = -3,
	/** 长整型 */
	kLong = 1071,
	/** 双精度浮点数 */
	kDouble = 1040,
	/** 字符串 */
	kString = 1000,
	/** 点坐标 */
	kPoint = 1010,
	/** 实体ID */
	kEntityId = -8000,
	/** 实体 */
	kEntity = -8500,
	/** 扩展数据名称 */
	kExDataName = 1001
}
/**
 * McDb 命名空间包含 AutoCAD 中的一些常用枚举。
 * @public
 */
export declare namespace McDb {
	/**
	 * 多线类型
	 * @public
	 */
	enum PolylineType {
		/** LW Polyline */
		kLwPolyline = 0,
		/** 3D Polyline */
		k3dPolyline = 2
	}
	/**
	 * 面域bool运行类型
	 * @public
	 */
	enum BooleanOptionType {
		/** 取交集 */
		Intersection = 0,
		/** 取并集 */
		Union = 1,
		/** 取差集 */
		Difference = 2,
		/** 取异或 */
		Xor = 3
	}
	/**
	 * 文本水平对齐方式枚举。
	 * @public
	 */
	enum TextHorzMode {
		/** 左对齐 */
		kTextLeft = 0,
		/** 居中对齐 */
		kTextCenter = 1,
		/** 右对齐 */
		kTextRight = 2,
		/** 水平对齐 */
		kTextAlign = 3,
		/** 垂直中间对齐 */
		kTextMid = 4,
		/** 自适应 */
		kTextFit = 5
	}
	/** 相交的类型
	 * 调用 {@link McDbEntity.IntersectWith} 方法的第二个参数
	 *  */
	enum Intersect {
		/** 两个实体都不延伸 */
		kOnBothOperands = 0,
		/** 只延伸原实体
		 * 指调用 {@link McDbEntity.IntersectWith} 方法的实例本身
		 *  */
		kExtendThis = 1,
		/**只延伸作为参数的实体
		 * 指 {@link McDbEntity.IntersectWith} 的第一个参数
		 *  */
		kExtendArg = 2,
		/** 两个实体都延伸  */
		kExtendBoth = 3
	}
	/**
	 * 文本垂直对齐方式枚举。
	 * @public
	 */
	enum TextVertMode {
		/** 基线对齐 */
		kTextBase = 0,
		/** 底部对齐 */
		kTextBottom = 1,
		/** 垂直中间对齐 */
		kTextVertMid = 2,
		/** 顶部对齐 */
		kTextTop = 3
	}
	/**
	 * 实体附着点枚举。
	 * @public
	 */
	enum AttachmentPoint {
		/** 左上对齐 */
		kTopLeft = 1,
		/** 中上对齐 */
		kTopCenter = 2,
		/** 右上对齐 */
		kTopRight = 3,
		/** 中左对齐 */
		kMiddleLeft = 4,
		/** 中心点对齐 */
		kMiddleCenter = 5,
		/** 中右对齐 */
		kMiddleRight = 6,
		/** 左下对齐 */
		kBottomLeft = 7,
		/** 底部中间对齐 */
		kBottomCenter = 8,
		/** 右下对齐 */
		kBottomRight = 9,
		kBaseLeft = 10,
		kBaseCenter = 11,
		kBaseRight = 12,
		kBaseAlign = 13,
		kBottomAlign = 14,
		kMiddleAlign = 15,
		kTopAlign = 16,
		kBaseFit = 17,
		kBottomFit = 18,
		kMiddleFit = 19,
		kTopFit = 20,
		kBaseMid = 21,
		kBottomMid = 22,
		kMiddleMid = 23,
		kTopMid = 24
	}
	/**
	 * 线宽枚举。
	 * @public
	 */
	enum LineWeight {
		kLnWt000 = 0,
		kLnWt005 = 5,
		kLnWt009 = 9,
		kLnWt013 = 13,
		kLnWt015 = 15,
		kLnWt018 = 18,
		kLnWt020 = 20,
		kLnWt025 = 25,
		kLnWt030 = 30,
		kLnWt035 = 35,
		kLnWt040 = 40,
		kLnWt050 = 50,
		kLnWt053 = 53,
		kLnWt060 = 60,
		kLnWt070 = 70,
		kLnWt080 = 80,
		kLnWt090 = 90,
		kLnWt100 = 100,
		kLnWt106 = 106,
		kLnWt120 = 120,
		kLnWt140 = 140,
		kLnWt158 = 158,
		kLnWt200 = 200,
		kLnWt211 = 211,
		kLnWtByLayer = -1,
		kLnWtByBlock = -2,
		kLnWtByLwDefault = -3
	}
	/**
	* 表示图案填充中不同类型的闭合区域
	* @public
	*/
	enum HatchLoopType {
		/** 默认填充闭合区域类型  */
		kDefault = 0,
		/** 外部填充闭合区域类型 表示外部轮廓或边界 */
		kExternal = 1,
		/** 多段线填充闭合区域类型 表示由多个线段组成的区域*/
		kPolyline = 2,
		/** 派生填充闭合区域类型 表示从其他图形元素派生而来的填充区域*/
		kDerived = 4,
		/** 文本框填充闭合区域类型 表示包含文本的区域*/
		kTextbox = 8,
		/** 最外层填充闭合区域类型 表示填充区域的最外层边界*/
		kOutermost = 16,
		/** 未闭合填充闭合区域类型 表示填充区域的边界没有闭合*/
		kNotClosed = 32,
		/** 自相交填充闭合区域类型 表示填充区域的边界自相交*/
		kSelfIntersecting = 64,
		/** 文本岛填充闭合区域类型  表示包含文本的孤立区域*/
		kTextIsland = 128
	}
	/**
	 * 表示填充区域中的边的曲线类型
	 * @public
	 */
	enum HatchEdgeType {
		/** 表示直线类型的边 */
		kLine = 1,
		/** 圆弧类型的边 */
		kCirArc = 2,
		/** 椭圆弧类型的边 */
		kEllArc = 3,
		/** 样条曲线类型的边 */
		kSpline = 4
	}
	/**
   *  表示填充图案的来源类型
   * @public
   */
	enum HatchPatternType {
		/** 用户自定义的填充图案 */
		kUserDefined = 0,
		/** 预定义的填充图案 */
		kPreDefined = 1,
		/** 自定义定义的填充图案 */
		kCustomDefined = 2
	}
	/**
	 * 表示填充图案的风格
	 * @public
	 * */
	enum HatchStyle {
		/** 普通风格 标准的、普通的填充图案风格 */
		kNormal = 0,
		/** 外部风格 填充会强调区域的外部边界 用于使外部区域在绘图中更为显眼 */
		kOuter = 1,
		/** 忽略风格 表示在某些情况下应忽略填充图案的风格 在特定的绘图需求下，不需要显示填充图案的情况*/
		kIgnore = 2
	}
	/** 指定裁剪操作中使用的边界类型*/
	enum ClipBoundaryType {
		/** 无效的裁剪边界类型 */
		kInvalid = 0,
		/** 矩形裁剪边界类型 */
		kRect = 1,
		/** 多边形裁剪边界类型 */
		kPoly = 2
	}
}
/**
 * McCmColor 是 CAD 中的颜色对象，用于统一表示颜色值和颜色索引，并为实体属性设置提供基础颜色数据。
 *
 * @description
 * 该类用于处理图形对象的颜色管理，既可以通过 RGB 值设置真实颜色，也可以通过颜色索引控制随层、随块等颜色模式。
 * 通过它可以完成：
 * - 创建和复制颜色对象；
 * - 设置 `RGB` 或颜色索引；
 * - 读取颜色字符串/样式；
 * - 将颜色应用到实体对象的 `trueColor` 或 `colorIndex` 属性。
 *
 * 使用方式：
 * 1. 构造 McCmColor 实例；
 * 2. 通过 `setRGB()` 或 `colorIndex` 赋值；
 * 3. 将对象赋给实体的颜色属性；
 * 4. 在需要时读取颜色字符串、样式或对象颜色值。
 *
 * 总结：在实际开发中，McCmColor 是实体颜色控制的基础类型，适用于图层颜色、对象颜色和界面颜色展示等场景。
 *
 * @example
 * ```ts
 * import { McCmColor, McDbEntity } from "mxcad";
 *
 * // 创建颜色对象并将其应用到实体颜色上。
 * async function testColor() {
 *   const ent = new McDbEntity();
 *   ent.trueColor = new McCmColor(255, 0, 0);
 *
 *   const color = new McCmColor();
 *   color.setRGB(0, 255, 0);
 *   console.log("颜色字符串:", color.getColorString());
 * }
 * ```
 */
export declare class McCmColor {
	/** 内部实现对象 */
	private imp;
	/**
	 * 构造函数。设置 RGB 值。
	 * @param red 红（0-255）
	 * @param green 绿（0-255）
	 * @param blue 蓝（0-255）
	 * @param n 透明度（0-255）
	 */
	constructor(red?: number | object, green?: number, blue?: number, n?: number);
	/**
	 * 获取内部实现对象
	 * @return 内部实现对象
	 */
	getImp(): any;
	/**
	 * 复制颜色对象的值。
	 * @param val 颜色对象
	 * @example
	 * ```ts
	 * import { McCmColor } from "mxcad"
	 *
	 * const color:McCmColor = new McCmColor();
	 * const red_color:McCmColor = new McCmColor(255, 0, 0);
	 * color.copy(red_color);
	 * ```
	 */
	copy(val: McCmColor): this;
	/**
	 * 刻隆一个颜色对象
	 * @return 返回克隆后的颜色对象
	 */
	clone(): McCmColor;
	/**
	 * 设置颜色索引,根据颜色索引值设置颜色类型。
	 * @param colorIndex 颜色索引。
	 * @example
	 * ```ts
	 * import { McCmColor, ColorIndexType } from "mxcad"
	 *
	 * const color = new McCmColor();
	 * color.setColorIndex(ColorIndexType.kBylayer);//设置颜色随层
	 * ```
	 */
	setColorIndex(colorIndex: number): void;
	/**
	 * 设置 RGB 值。
	 * @param red 红色值。
	 * @param green 绿色值。
	 * @param blue 蓝色值。
	 */
	setRGB(red: number, green: number, blue: number): void;
	/**
	 * 获取或设置rgb值中的红色值，设置数值范围0~255。
	 * @param val 颜色数值
	 */
	get red(): number;
	set red(val: number);
	/**
	 * 获取或设置rgb值中的绿色值，设置数值范围0~255。
	 * @param val 颜色数值
	 */
	get green(): number;
	set green(val: number);
	/**
	 * 获取或设置rgb值中的蓝色值，设置数值范围0~255。
	 * @param val 颜色数值
	 */
	get blue(): number;
	set blue(val: number);
	/**
	 * 获取或设置颜色透明度，设置数值范围0~255。
	 * 0完全透明，160半透明（中间值），255完全不透明
	 */
	get n(): number;
	set n(val: number);
	/**
	 * 方法。
	 */
	get method(): number;
	set method(val: number);
	/**
	 * 获取或设置颜色索引。
	 * @param val 颜色索引
	 * @example
	 * ```ts
	 * import { McCmColor, ColorIndexType } from "mxcad"
	 *
	 * const color = new McCmColor();
	 * color.colorIndex = ColorIndexType.kBylayer;//设置颜色随层
	 * console.log(color.colorIndex);
	 * ```
	 */
	get colorIndex(): number;
	set colorIndex(val: number);
	/**
	 * 得到颜色说明字符串
	 * @returns 颜色说明字符串
	 */
	getColorString(): string;
	/**
	 * 得到颜色值字符串，十六进制格式，layerId:颜色随层时会取layerId指向的层颜色，blkRefId:颜色随块时，会取blkRefId指向的块颜色
	 * @param layerId 图层ID
	 * @param blkRefId 块记录ID
	 * @returns 颜色值字符串
	 */
	getColorValue(layerId?: McObjectId, blkRefId?: McObjectId): string;
	/** 获取 css 颜色的样式 如rgb(0, 0, 0) */
	getStyle(): string;
}
/**
 * McDbLinetypeTableRecord 是线型表中的单条记录，负责保存和管理某一条线型定义。
 *
 * @description
 * 该类用于描述一条线型的具体参数，如线型名称、虚线长度、偏移、缩放和文本说明。
 * 通过它可以完成：
 * - 创建并保存一条自定义线型；
 * - 读取和设置线型名称、虚线参数和说明信息；
 * - 控制线型中的形状、偏移、旋转和缩放属性；
 * - 作为线型表中的记录对象参与图纸样式管理。
 *
 * 使用方式：
 * 1. 创建 McDbLinetypeTableRecord 实例；
 * 2. 设置 name / numDashes / dashLengthAt 等属性；
 * 3. 将实例添加到线型表中；
 * 4. 通过样式表应用到图形对象上。
 *
 * 总结：在实际开发中，McDbLinetypeTableRecord 用于定义和编辑一条线型，是线型样式控制的最细粒度对象。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbLinetypeTableRecord } from "mxcad";
 *
 * // 创建并配置一条自定义线型记录。
 * async function testLinetypeRecord() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const table = mxcad.getDatabase().getLinetypeTable();
 *   const rec = new McDbLinetypeTableRecord();
 *   rec.name = "MyDashLine";
 *   rec.numDashes = 2;
 *   rec.setDashLengthAt(0, 8);
 *   rec.setDashLengthAt(1, 4);
 *   table.add(rec);
 * }
 * ```
 */
export declare class McDbLinetypeTableRecord extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置线型名称。
	 */
	get name(): string;
	set name(val: string);
	/**
	 * 获取或设置线型的虚线数量
	 */
	get numDashes(): number;
	set numDashes(val: number);
	/**
	 * 获取或设置指定索引处的虚线长度。
	 * @param index 线型定义数组中索引。
	 * @param value 虚线长度
	 */
	dashLengthAt(index: number): number;
	setDashLengthAt(index: number, value: number): boolean;
	/**
	 * 获取或设置线型说明字符串。
	 */
	get comments(): string;
	set comments(val: string);
	/**
	 *  获取或设置指定索引处的形状样式。
	 * @param index 线型定义数组中索引。
	 */
	shapeStyleAt(index: number): McObjectId;
	setShapeStyleAt(index: number, id: McObjectId): boolean;
	/**
	 *  获取或设置指定索引处的形状编号。
	 * @param index 线型定义数组中索引。
	 */
	shapeNumberAt(index: number): number;
	setShapeNumberAt(index: number, shapeNumber: number): boolean;
	/**
	 *  获取或设置指定索引处的形状偏移量。
	 * @param index 线型定义数组中索引。
	 * @return 偏移向量
	 */
	shapeOffsetAt(index: number): McGeVector3d;
	setShapeOffsetAt(index: number, offset: McGeVector3d): boolean;
	/**
	 * 获取或设置指定索引处的形状缩放比例。
	 * @param index 线型定义数组中索引。
	 * @param scale 缩放因子
	 */
	shapeScaleAt(index: number): number;
	setShapeScaleAt(index: number, scale: number): boolean;
	/**
	 * 获取或设置线型是否根据绘图比例进行缩放。
	 * @return 布尔值
	 */
	get isScaledToFit(): boolean;
	set isScaledToFit(scaledToFit: boolean);
	/**
	 * 获取指定形状是否按照用户坐标系（UCS）方向排列。
	 * @param index 线型定义数组中索引。
	 */
	shapeIsUcsOrientedAt(index: number): boolean;
	/**
	 * 设置指定形状是否按照用户坐标系（UCS）方向排列。
	 * @param index 线型定义数组中索引。
	 * @param isUcsOriented 是否按照用户坐标系（UCS）方向排列
	 * @returns 布尔值
	 */
	setShapeIsUcsOrientedAt(index: number, isUcsOriented: boolean): boolean;
	/**
	 * 获取指定索引处的形状旋转角度。
	 * @param index 线型定义数组中索引。
	 * @return 旋转角度
	 */
	shapeRotationAt(index: number): number;
	/**
	 * 设置指定索引处的形状旋转角度。
	 * @param index 线型定义数组中索引。
	 * @param rotation 旋转角度
	 * @returns 布尔值
	 */
	setShapeRotationAt(index: number, rotation: number): boolean;
	/**
	 * 获取或设置指定索引处的文本信息。
	 * @param index 线型定义数组中索引。
	 * @return 文本信息
	 */
	textAt(index: number): string;
	/**
	 * 设置指定索引处的文本信息。
	 * @param index 线型定义数组中索引。
	 * @param text 文本信息
	 * @returns 布尔值
	 */
	setTextAt(index: number, text: string): boolean;
}
/**
 * McDbDimStyleTableRecord 是标注样式表中的单条记录，负责保存和管理尺寸标注样式参数。
 *
 * @description
 * 该类用于描述一套尺寸标注样式，包括文字、箭头、尺寸线和单位相关参数。
 * 通过它可以完成：
 * - 读取和设置标注样式名称；
 * - 修改尺寸变量的 int / double / string / ObjectId 属性；
 * - 配置块引用样式（Dimblk、Dimblk1、Dimblk2 等）；
 * - 作为标注样式表中的记录对象参与尺寸样式管理。
 *
 * 使用方式：
 * 1. 创建 McDbDimStyleTableRecord 实例；
 * 2. 调用 getDimVar* / setDimVar* 设置样式参数；
 * 3. 将该记录添加到标注样式表中；
 * 4. 应用到具体的标注对象中。
 *
 * 具体样式参数的设置可参考 `McObject.addDimStyle` 中的注释说明，`addDimStyle` 最终也是按 DIM 系统变量分组写入：
 * - double 型参数：如 dimscale、dimtxt、dimasz、dimexo、dimexe、dimrnd、dimdli 等；
 * - int 型参数：如 dimadec、dimalt、dimclrd、dimclre、dimclrt、dimfit、dimjust、dimtol、dimzin 等；
 * - string 型参数：如 dimpost、dimapost；
 * - ObjectId 型参数：如 dimtxsty、dimblk、dimblk1、dimblk2、dimldrblk；
 *
 * 也就是说，`McDbDimStyleTableRecord` 中的 `setDimVarDouble(type, value)`、`setDimVarInt(type, value)`、
 * `setDimVarString(type, value)` 和 `setDimVarObjectId(type, value)` 与 `addDimStyle(pszName, pszDoubleData, pszIntData, pszStringData, pszIdData)`
 * 中的参数分组完全对应。调用时可直接使用注释里列出的系统变量编号和含义。
 *
 * 例如：
 * - `setDimVarDouble(40, 200)` 等价于设置 `dimscale = 200`；
 * - `setDimVarDouble(41, 0.18)` 等价于设置 `dimasz = 0.18`；
 * - `setDimVarInt(77, 1)` 等价于设置 `dimtol = 1`；
 * - `setDimVarInt(271, 3)` 等价于设置 `dimdec = 3`；
 * - `setDimVarString(3, "%%c<>")` 等价于设置 `dimpost = "%%c<>"`；
 * - `setDimVarObjectId(340, textId)` 等价于设置 `dimtxsty = textId`。
 *
 * 总结：在实际开发中，McDbDimStyleTableRecord 是尺寸风格统一管理的核心对象，适合控制尺寸样式、箭头和文本参数。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbDimStyleTableRecord } from "mxcad";
 *
 * // 创建并设置尺寸标注样式记录。
 * async function testDimStyleRecord() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const table = mxcad.getDatabase().getDimStyleTable();
 *   const rec = new McDbDimStyleTableRecord();
 *   rec.name = "MyDimStyle";
 *   rec.setDimVarDouble(40, 200);   // dimscale
 *   rec.setDimVarDouble(41, 0.18);  // dimasz
 *   rec.setDimVarInt(77, 1);        // dimtol
 *   rec.setDimVarInt(271, 3);       // dimdec
 *   rec.setDimVarString(3, "%%c<>"); // dimpost
 *   table.add(rec);
 * }
 * ```
 */
export declare class McDbDimStyleTableRecord extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置标注样式名称。
	 */
	get name(): string;
	set name(val: string);
	/**
	* 得到标注样式的整数类型的属性。
	*/
	getDimVarInt(type: number): number;
	/**
	* 设置标注样式的整数类型的属性。
	*/
	setDimVarInt(type: number, value: number): boolean;
	/**
	* 得到标注样式的double类型的属性。
	*/
	getDimVarDouble(type: number): number;
	/**
	* 设置标注样式的double类型的属性。
	*/
	setDimVarDouble(type: number, value: number): boolean;
	/**
	* 得到标注样式的string类型的属性。
	*/
	getDimVarString(type: number): string;
	/**
	* 设置标注样式的string类型的属性。
	*/
	setDimVarString(type: number, value: string): boolean;
	/**
   * 得到标注样式的整数类型的属性。
   */
	getDimVarObjectId(type: number): McObjectId;
	/**
	* 设置标注样式的整数类型的属性。
	*/
	setDimVarObjectId(type: number, value: McObjectId): boolean;
	/**
	* 得到标注样式的Dimblk属性。
	*/
	getDimblk(): string;
	/**
	* 设置标注样式的Dimblk属性。
	*/
	setDimblk(value: string): boolean;
	/**
	* 得到标注样式的Dimblk1属性。
	*/
	getDimblk1(): string;
	/**
	* 设置标注样式的Dimblk1属性。
	*/
	setDimblk1(value: string): boolean;
	/**
	* 得到标注样式的Dimblk2属性。
	*/
	getDimblk2(): string;
	/**
	* 设置标注样式的Dimblk2属性。
	*/
	setDimblk2(value: string): boolean;
	/**
   * 得到标注样式的Dimldrblk属性。
   */
	getDimldrblk(): string;
	/**
	* 设置标注样式的Dimblk属性。
	*/
	setDimldrblk(value: string): boolean;
}
/**
 * McDbTextStyleTableRecord 是文字样式表中的单条记录，用于保存和管理文本字体样式参数。
 *
 * @description
 * 该类用于描述一套文本样式，如字体名称、大小、倾斜角、宽度因子和大字体参数。
 * 通过它可以完成：
 * - 创建和配置文字样式；
 * - 设置字体、大小、斜体、宽度和标志位；
 * - 保存到文字样式表中；
 * - 将样式应用到文本对象或注释对象上。
 *
 * 使用方式：
 * 1. 创建 McDbTextStyleTableRecord 实例；
 * 2. 设置 name、fileName、textSize、xScale 等属性；
 * 3. 添加到文字样式表后应用到文本对象中。
 *
 * 总结：在实际开发中，McDbTextStyleTableRecord 是文字风格和字体控制的最细粒度对象，适合统一管理文本样式。
 *
 * @example
 * ```ts
 * import { McCmColor, MxCpp, McDbTextStyleTableRecord, McDb } from "mxcad"
 *
 * // 创建并设置文字样式记录。
 * async function testTextStyleRecord() {

	const mxcad = MxCpp.getCurrentMxCAD();
	// 拿到当前文字样式表
	const textSyleTable = mxcad.getDatabase().getTextStyleTable();
	// 构造一个文字样式表记录对象
	let newTextStyleRecord = new McDbTextStyleTableRecord();
	// 设置对象文件名
	newTextStyleRecord.fileName = "txt.shx";
	// 设置对象大字体名称
	newTextStyleRecord.bigFontFileName = "hztxt.shx";
	// 设置对象文字大小
	newTextStyleRecord.textSize = 10;
	// 设置对象名
	newTextStyleRecord.name = sMyTextStyle;
	// 设置对象宽度因子
	newTextStyleRecord.xScale = 0.7;
	// 添加文字样式
	const res = textSyleTable.add(newTextStyleRecord).isValid()
	if (res) {
	  console.log("add ok");
	}
 * }
 * ```
 */
export declare class McDbTextStyleTableRecord extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置文字样式名称。
	 */
	get name(): string;
	set name(val: string);
	/**
	 * 获取或设置文本样式是否使用形状字体
	 */
	get isShapeFile(): boolean;
	set isShapeFile(val: boolean);
	/**
	 * 获取或设置文本样式是否使用斜体
	 */
	get isVertical(): boolean;
	set isVertical(val: boolean);
	/**
	 * 文字大小(高度)
	 */
	get textSize(): number;
	set textSize(val: number);
	/**
	 * 缩放因子大小
	 */
	get xScale(): number;
	set xScale(val: number);
	/**
	 * 倾斜角度
	 */
	get obliquingAngle(): number;
	set obliquingAngle(val: number);
	/**
	 * 获取或设置文本样式表记录的一组标志位
	 */
	get flagBits(): number;
	set flagBits(val: number);
	/**
	 * 字体文件名称
	 */
	get fileName(): string;
	set fileName(val: string);
	/**
	 * 大字体文件名称
	 */
	get bigFontFileName(): string;
	set bigFontFileName(val: string);
	/**
	 * 设置字体样式
	 * @param sTypeface 字体名称
	 * @param bold 是否粗体
	 * @param italic 是否斜体
	 * @param charset 字符集
	 * @param pitchAndFamily 字体间距和风格
	 * @returns 是否设置成功
	 * @example
	 * ```ts
	 * import { McDbTextStyleTableRecord } from 'mxcad';
	 *
	 * const newTextStyleRecord = new McDbTextStyleTableRecord();
	 * // 设置字体
	 * const typeface = "Arial"; // 字体名称
	 * const isBold = true; // 是否粗体
	 * const isItalic = false; // 是否斜体
	 * const charset = 0; // 字符集
	 * const pitchAndFamily = 0; // 字体间距和风格
	 * const isSetFontSuccessful = newTextStyleRecord.setFont(typeface, isBold, isItalic, charset, pitchAndFamily);
	 * // 检查设置是否成功
	 * if (isSetFontSuccessful) {
	 *  console.log("Font set successfully.");
	 * } else {
	 *  console.log("Failed to set font.");
	 * }
	 * ```
	 */
	setFont(sTypeface: string, bold: boolean, italic: boolean, charset: number, pitchAndFamily: number): boolean;
	/**
	 * 获取字体样式
	 * @returns { object } sTypeface: 字体名称 | bold: 是否粗体 | italic: 是否斜体 | charset: 字符集 | pitchAndFamily: 字体间距和风格
	 */
	font(): {
		sTypeface: string;
		bold: boolean;
		italic: boolean;
		charset: number;
		pitchAndFamily: number;
	};
}
/**
 * McDbLayerTableRecord 是图层表中的单条记录，用于保存和管理图层的属性。
 *
 * @description
 * 该类用于描述一张图层，包括图层名、颜色、线型、锁定状态、冻结状态和是否关闭等。
 * 通过它可以完成：
 * - 新建和命名图层；
 * - 设置图层颜色、线宽、线型和可打印性；
 * - 控制图层是否被冻结、锁定或关闭；
 * - 将图层对象添加到图层表中并用于后续实体归属。
 *
 * 使用方式：
 * 1. 创建 McDbLayerTableRecord 实例；
 * 2. 设置 name / color / lineWeight / isLocked 等属性；
 * 3. 插入到图层表中；
 * 4. 使用其对象 ID 为实体指定图层。
 *
 * 总结：在实际开发中，McDbLayerTableRecord 是图层属性控制的最细粒度对象，适合统一管理图层状态和显示规则。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbLayerTableRecord, McCmColor, McDb } from "mxcad";
 *
 * // 创建并配置图层记录。
 * async function testLayerRecord() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   // 构造新图层表记录对象
 *   const layer = new McDbLayerTableRecord()
 *   // 设置图层颜色
 *   layer.color = new McCmColor(0, 0, 0)
 *   // 设置图层是否被冻结
 *   layer.isFrozen = true
 *   // 设置图层是否被锁定
 *   layer.isLocked = true
 *   // 设置图层是否被关闭
 *   layer.isOff = true
 *   // 设置图层线宽
 *   layer.lineWeight = McDb.LineWeight.kLnWt018
 *   // 设置图层名
 *   layer.name = "图层名称"
 *   // 获取当前图层表
 *   const layerTable = mxcad.getDatabase().getLayerTable();
 *   // 向图表中添加图层
 *   const objId = layerTable.add(layer)
 * }
 * ```
 */
export declare class McDbLayerTableRecord extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置图层名称。
	 */
	get name(): string;
	set name(val: string);
	/**
	 * 获取或设置图层是否被冻结。
	 */
	get isFrozen(): boolean;
	set isFrozen(val: boolean);
	/**
	 * 获取或设置图层是否被关闭。
	 */
	get isOff(): boolean;
	set isOff(val: boolean);
	/**
	 * 获取或设置图层是否被锁定。
	 */
	get isLocked(): boolean;
	set isLocked(val: boolean);
	/**
	 * 获取或设置图层是可打印。
	 */
	get isPlottable(): boolean;
	set isPlottable(val: boolean);
	/**
	 * 获取或设置图层颜色。
	 */
	get color(): McCmColor;
	set color(val: McCmColor);
	/**
	 * 获取或设置图层线型对象 ID。
	 */
	get linetypeObjectId(): McObjectId;
	set linetypeObjectId(val: McObjectId);
	/**
	 * 获取或设置图层线宽。
	 */
	get lineWeight(): McDb.LineWeight;
	set lineWeight(val: McDb.LineWeight);
}
/**
 * McDbLayerTable 是数据库中的图层表，负责管理当前图纸中的所有图层记录。
 *
 * @description
 * 该类用于管理 CAD 图层的集合，便于查询、添加、判断和访问图层对象。
 * 通过它可以完成：
 * - 获取图层表中所有图层记录 ID；
 * - 向图层表中新增图层；
 * - 按名称查找某个图层；
 * - 判断某个图层是否存在；
 * - 后续通过 McObjectId 获取真正的 McDbLayerTableRecord 进行属性编辑。
 *
 * 使用方式：
 * 1. 先通过数据库对象获取当前图层表；
 * 2. 调用 getAllRecordId() 获取所有图层 ID；
 * 3. 使用 add() / get() / has() 管理图层；
 * 4. 对返回的图层记录继续设置颜色、状态、线宽等属性。
 *
 * 总结：在实际开发中，McDbLayerTable 主要用于统一管理图层资源，是图层增删查改和图层状态控制的核心入口。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbLayerTable } from "mxcad";
 *
 * // 创建图层表并向其中添加图层记录。
 * async function testLayerTable() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const layerTable: McDbLayerTable = mxcad.getDatabase().getLayerTable();
 *
 *   const aryId = layerTable.getAllRecordId();
 *   console.log("图层数量:", aryId.length);
 *
 *   aryId.forEach((id) => {
 *     const layerRec = id.getMcDbLayerTableRecord();
 *     if (!layerRec) return;
 *     console.log("图层名:", layerRec.name);
 *   });
 *
 *   const exists = layerTable.has("测试图层");
 *   console.log("是否存在测试图层:", exists);
 * }
 * ```
 */
export declare class McDbLayerTable extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取层表中的所有图层记录的ID。
	 * @param skipDeleted 是否跳过已删除图层。
	 * @returns 图层ID数组
	 */
	getAllRecordId(skipDeleted?: boolean): McObjectId[];
	/**
	 * 向图层表中添加图层记录。
	 * @param rec 图层表记录对象。
	 * @returns 新增图层记录对象ID。
	 * @example
	 * ```ts
	 * import { MxCpp, McDbLayerTable } from "mxcad";
	 *
	 * const layerTable:McDbLayerTable = MxCpp.getCurrentMxCAD().getDatabase().getLayerTable();
	 * const layerRec = new McDbLayerTableRecord();
	 * const id = layerTable.add(layerRec);
	 * ```
	 */
	add(rec: McDbLayerTableRecord): McObjectId;
	/**
	 * 查找图层表中的图层记录。
	 * @param sName 图层名称。
	 * @param skipDeleted 是否跳过已删除图层。
	 * @returns 图层记录对象ID。
	 */
	get(sName: string, skipDeleted?: boolean): McObjectId;
	/**
	 * 检查图层表中是否存在指定名称的图层记录。
	 * @param sName 图层名称。
	 * @param skipDeleted 是否跳过已删除图层。
	 * @returns 布尔值。
	 */
	has(sName: string, skipDeleted?: boolean): boolean;
}
/**
 * McDbLinetypeTable 是数据库中的线型表，用于管理当前图纸中的所有线型定义。
 *
 * @description
 * 该类用于维护和访问图纸中的线型集合，包括获取线型记录、添加新线型、按名称定位线型等操作。
 * 通过它可以完成：
 * - 获取全部线型记录 ID；
 * - 添加新的线型记录；
 * - 根据名称查找线型；
 * - 判断线型是否存在；
 * - 后续通过 McObjectId 获取真实的 McDbLinetypeTableRecord 进行编辑。
 *
 * 使用方式：
 * 1. 从数据库中获取当前线型表 `MxCpp.getCurrentMxCAD().getDatabase().getLinetypeTable()`；
 * 2. 调用 getAllRecordId() 查看线型列表；
 * 3. 使用 add() / get() / has() 进行管理；
 * 4. 对返回记录对象设置线型名称和属性。
 *
 * 总结：在实际开发中，McDbLinetypeTable 是CAD线型管理的入口，适用于线型定义、线型选择和样式控制等场景。
 *
 * @example
 * ```ts
 * // 获取所有线型
 * import { MxCpp, McDbLinetypeTable } from "mxcad"
 *   // 获取当前CAD对象
 *   let mxcad = MxCpp.getCurrentMxCAD();
 *   // 获取数据库线型表
 *   let linetypeTable: McDbLinetypeTable = mxcad.getDatabase().getLinetypeTable();
 *   // 获取线性表中的所有线型表记录对象ID
 *   let aryId = linetypeTable.getAllRecordId();
 *   // 遍历线型表记录对象
 *   aryId.forEach((id) => {
 *   let linetypeRec = id.getMcDbLinetypeTableRecord();
 *   if (linetypeRec === null) return;
 *   console.log(linetypeRec);
 *   console.log("linetypeRec.name:" + linetypeRec.name);
 * });
 * ```
 */
export declare class McDbLinetypeTable extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取线型表中的所有线型记录的ID。
	 * @param skipDeleted 是否跳过已删除线型。
	 * @returns ret 线型ID数组。
	 */
	getAllRecordId(skipDeleted?: boolean): McObjectId[];
	/**
	 * 向线型表中添加线型记录。
	 * @param rec 线型表记录对象。
	 * @returns 新增线型记录对象ID。
	 * @example
	 * ```ts
	 * import { MxCpp, McDbLinetypeTable } from "mxcad";
	 *
	 * let mxcad = MxCpp.getCurrentMxCAD();
	 * let linetypeTable: McDbLinetypeTable = mxcad.getDatabase().getLinetypeTable();
	 * let newLinetypeRecord = new McDbLinetypeTableRecord();
	 * const id = linetypeTable.add(newLinetypeRecord);
	 * console.log(id)
	 * ```
	 */
	add(rec: McDbLinetypeTableRecord): McObjectId;
	/**
	 * 查找线型表中的线型记录。
	 * @param sName 线型名称。
	 * @param skipDeleted 是否跳过已删除线型。
	 * @returns 线型记录对象ID。
	 */
	get(sName: string, skipDeleted?: boolean): McObjectId;
	/**
	 * 检查线型表中是否存在指定名称的线型记录。
	 * @param sName 线型名称。
	 * @param skipDeleted 是否跳过已删除线型。
	 * @returns 布尔值。
	 */
	has(sName: string, skipDeleted?: boolean): boolean;
}
/**
 * McDbDimStyleTable 是数据库中的标注样式表，负责管理图纸中的所有标注样式定义。
 *
 * @description
 * 该类用于维护和访问 CAD 标注样式集合，适合对尺寸样式、文字样式、单位显示等标注相关属性进行统一管理。
 * 通过它可以完成：
 * - 获取全部标注样式记录 ID；
 * - 新增和查询标注样式；
 * - 按名称判断样式是否存在；
 * - 后续通过对象 ID 访问具体的 McDbDimStyleTableRecord 继续设置样式参数。
 *
 * 使用方式：
 * 1. 通过数据库获取当前标注样式表；
 * 2. 使用 getAllRecordId() 列出全部样式；
 * 3. 调用 add() / get() / has() 管理样式；
 * 4. 将样式应用到当前标注对象或新创建的标注。
 *
 * 总结：在实际开发中，McDbDimStyleTable 是标注样式管理和尺寸规范控制的核心入口，适合统一设置标注风格。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbDimStyleTable } from "mxcad";
 *
 * // 创建尺寸样式表并添加样式记录。
 * async function testDimStyleTable() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const table: McDbDimStyleTable = mxcad.getDatabase().getDimStyleTable();
 *   const ids = table.getAllRecordId();
 *   console.log("标注样式数量:", ids.length);
 * }
 * ```
 */
export declare class McDbDimStyleTable extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取所有的注样式。
	 * @param skipDeleted 是否跳过已删除注样式。
	 * @returns 注样式ID数组
	 */
	getAllRecordId(skipDeleted?: boolean): McObjectId[];
	/**
	 * 向标注样式表中添加标注样式记录。
	 * @param rec 标注样式记录。
	 * @returns 新增线型记录对象ID。
	 * ```ts
	 */
	add(rec: McDbDimStyleTableRecord): McObjectId;
	/**
	 * 查找标注样式表中的标注样式记录。
	 * @param sName 标注样式名称。
	 * @param skipDeleted 是否跳过已删除标注样式。
	 * @returns 标注样式记录对象ID。
	 */
	get(sName: string, skipDeleted?: boolean): McObjectId;
	/**
	 * 检查找标注样式表中是否存在指定名称的找标注样式记录。
	 * @param sName 找标注样式名称。
	 * @param skipDeleted 是否跳过已删除找标注样式。
	 * @returns 布尔值。
	 */
	has(sName: string, skipDeleted?: boolean): boolean;
}
/**
 * McDbTextStyleTable 是数据库中的文字样式表，用于管理当前图纸中的所有文字样式定义。
 *
 * @description
 * 该类用于维护与访问文字样式集合，支持文字样式的查看、创建和名称检索。
 * 通过它可以完成：
 * - 获取全部文字样式记录 ID；
 * - 添加新的文字样式；
 * - 按名称查找指定样式；
 * - 判断样式是否存在；
 * - 后续通过对象 ID 获取 McDbTextStyleTableRecord 进行参数设置。
 *
 * 使用方式：
 * 1. 从数据库中获取文字样式表 `MxCpp.getCurrentMxCAD().getDatabase().getTextStyleTable()`；
 * 2. 调用 getAllRecordId() 获取所有样式；
 * 3. 使用 add() / get() / has() 管理样式；
 * 4. 将选中的样式用于文字对象或注释对象。
 *
 * 总结：在实际开发中，McDbTextStyleTable 主要用于统一管理文字样式，是文本对象字体、尺寸和排版控制的基础入口。
 *
 * @example
 * ```ts
 * // 获取所有文字样式
 * import { MxCpp, McDbTextStyleTable } from "mxcad"
 *   // 获取当前CAD对象
 *   let mxcad = MxCpp.getCurrentMxCAD();
 *   // 获取数据库文字样式表
 *   let textSyleTable: McDbTextStyleTable = mxcad.getDatabase().getTextStyleTable();
 *   // 获取文字样式表中的所有文字样式表记录对象ID
 *   let aryId = textSyleTable.getAllRecordId();
 *   // 遍历文字样式表记录对象
 *   aryId.forEach((id) => {
 *       let textSyleRec = id.getMcDbTextStyleTableRecord();
 *       if (textSyleRec === null) return;
 *       console.log(textSyleRec);
 *       console.log("textSyleRec.fileName:" + textSyleRec.fileName);
 *       console.log("textSyleRec.name:" + textSyleRec.name);
 *   });
 * ```
 */
export declare class McDbTextStyleTable extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取文字样式表中的所有文字样式记录的ID。
	 * @param skipDeleted 是否跳过已删除文字样式。
	 * @returns ret 文字样式ID数组。
	 */
	getAllRecordId(skipDeleted?: boolean): McObjectId[];
	/**
	 * 向文字样式表中添加文字样式记录。
	 * @param rec 文字样式表记录对象。
	 * @returns 新增文字样式记录对象ID。
	 * @example
	 * ```ts
	 * import { MxCpp, McDbTextStyleTable } from "mxcad"
	 *
	 * let mxcad = MxCpp.getCurrentMxCAD();
	 * let textSyleTable: McDbTextStyleTable = mxcad.getDatabase().getTextStyleTable();
	 *
	 * const newTextStyleRecord = new McDbTextStyleTableRecord();
	 * const id = textSyleTable.add(newTextStyleRecord);
	 * console.log(id)
	 * ```
	 */
	add(rec: McDbTextStyleTableRecord): McObjectId;
	/**
	 * 查找文字样式表中的文字样式记录。
	 * @param sName 文字样式名称。
	 * @param skipDeleted 是否跳过已删除文字样式。
	 * @returns 文字样式记录对象ID。
	 */
	get(sName: string, skipDeleted?: boolean): McObjectId;
	/**
	 * 检查文字样式表中是否存在指定名称的文字样式记录。
	 * @param sName 文字样式名称。
	 * @param skipDeleted 是否跳过已删除文字样式。
	 * @returns 布尔值。
	 */
	has(sName: string, skipDeleted?: boolean): boolean;
}
/**
 * McDbDatabase 是 CAD 图纸数据库对象，承载图纸中所有数据和对象信息的总入口。
 *
 * @description
 * 该类表示当前图纸的数据库容器，保存着层表、线型表、文字样式表、块表、字典等核心数据结构。
 * 通过它可以完成：
 * - 获取和管理图层、线型、样式、块表等表对象；
 * - 设置当前图层、当前颜色、当前文字样式和当前线型；
 * - 读写文件、插入块、创建组、处理命名对象字典；
 * - 对当前数据库的修改状态进行查询和重置。
 *
 * 使用方式：
 * 1. 通过 MxCpp.getCurrentMxCAD().getDatabase() 获取数据库实例；
 * 2. 调用 getLayerTable()、getBlockTable()、getTextStyleTable() 等方法访问各类表；
 * 3. 使用 setCurrentlyLayerName()、setCurrentlyTrueColor()、setCurrentlyTextStyle() 等设置当前绘图状态；
 * 4. 根据需要访问命名对象字典、创建组或保存/读取图纸文件。
 *
 * 总结：在实际开发中，McDbDatabase 是整个图纸数据的总入口，几乎所有图层、块、样式、字典和对象管理都需要从它开始。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbDatabase } from "mxcad";
 *
 * // 获取当前数据库并进行基本操作。
 * async function testDatabase() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const database: McDbDatabase = mxcad.getDatabase();
 *
 *   const layerTable = database.getLayerTable();
 *   console.log("图层表对象:", layerTable);
 *
 *   const blockTable = database.getBlockTable();
 *   console.log("块表对象:", blockTable);
 *
 *   database.setCurrentlyLayerName("0");
 *   console.log("当前图层:", database.getCurrentlyLayerName());
 * }
 * ```
 */
export declare class McDbDatabase extends McRxObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 得到UCS用户坐标系变换矩阵
	 */
	get ucsMatrix(): McGeMatrix3d;
	/**
	* 设置UCS用户坐标系变换矩阵
	*/
	set ucsMatrix(val: McGeMatrix3d);
	/**
	 * 获取层表。
	 * @returns 层表。
	 * @example
	 * ```ts
	   import { MxCADUiPrEntity, MxCpp } from "mxcad";
	   //隐藏目标对象所在图层
	   async function Mx_SelectEntitHideLayer() {
		  let selEntity1 = new MxCADUiPrEntity();

		  selEntity1.setMessage("选择要隐藏的对象")
		  let id = await selEntity1.go();
		  if (!id.isValid()) return;

		  let ent = id.getMcDbEntity();
		  let mxcad = MxCpp.getCurrentMxCAD();
		  let layerTable = mxcad.getDatabase().getLayerTable();
		  let layerId = layerTable.get(ent.layer);
		  let layerRec = layerId.getMcDbLayerTableRecord();
		  if (layerRec === null) return;
		  layerRec.isOff = true;
		  mxcad.updateLayerDisplayStatus();
		  mxcad.updateDisplay()
		}
	 * ```
	 */
	getLayerTable(): McDbLayerTable;
	/**
	 * 写块
	 */
	wblock(database: McDbDatabase, aryId: McObjectId[], ptBase?: McGePoint3d, param?: object): boolean;
	/**
	 * 插入图块
	 */
	insert(database: McDbDatabase, sBlkName: string): McObjectId;
	/**
	 * 读取文件。
	 */
	readFile(sFilePath: string): boolean;
	/**
	 * 保存文件。
	 */
	saveAs(sFilePath: string, sJsonParam?: string): boolean;
	/**
	 * 获取层表
	 */
	get layerTable(): McDbLayerTable;
	/**
	 * 获取线型表。
	 * @returns 线型表。
	 * @example
	 * ```ts
		import { MxCpp } from "mxcad"
		//得所有线型
		let mxcad = MxCpp.App.getCurrentMxCAD();
		let linetypeTable = mxcad.getDatabase().getLinetypeTable();
		let aryId = linetypeTable.getAllRecordId();
		aryId.forEach((id) => {
			let linetypeRec = id.getMcDbLinetypeTableRecord();
			if (linetypeRec === null) return;
			console.log(linetypeRec);
		});
	 * ```
	 */
	getLinetypeTable(): McDbLinetypeTable;
	/**
	* 获取标注样式表。
	* @returns 线型表。
	*/
	getDimStyleTable(): McDbDimStyleTable;
	/**
	 * 获取标注样式表。
	 * @returns 线型表。
	 */
	get dimStyleTable(): McDbDimStyleTable;
	/**
	 * 获取线型表
	 */
	get linetypeTable(): McDbLinetypeTable;
	/**
	 * 获取文字样式表。
	 * @returns 文字样式表。
	 * @example
	 * ```ts
	  //获取所有文字样式
	  import { MxCpp } from "mxcad"
	  let mxcad = MxCpp.getCurrentMxCAD();
	  let textSyleTable = mxcad.getDatabase().getTextStyleTable();
	  let aryId = textSyleTable.getAllRecordId();
	  aryId.forEach((id) => {
		  let textSyleRec = id.getMcDbTextStyleTableRecord();
		  if (textSyleRec === null) return;
		  let out: any = {};
		  out.name = textSyleRec.name;
		  out.font = textSyleRec.font();
		  out.fileName = textSyleRec.fileName;
		  out.bigFontFileName = textSyleRec.bigFontFileName;
		  out.textSize = textSyleRec.textSize;
		  out.xScale = textSyleRec.xScale;
		  console.log(out);
	  });
	 * ```
	 */
	getTextStyleTable(): McDbTextStyleTable;
	/**
	 * 获取文字样式表
	 */
	get textStyleTable(): McDbTextStyleTable;
	/**
	 * 获取块表。
	 * @returns 块表。
	 * @example
	 * ```ts
	   import { MxCpp, McDbDatabase } from "mxcad"
	   let mxcad = MxCpp.App.getCurrentMxCAD();
	   let blockTable = mxcad.getDatabase().getBlockTable();
	   let aryId = blockTable.getAllRecordId();
	   aryId.forEach((id) => {
		   let blkRec = id.getMcDbBlockTableRecord();
		   if (blkRec === null) return;
		   console.log(blkRec);
		   console.log("blkRec.name:" + blkRec.name);
		   console.log("blkRec.origin:" + blkRec.origin);
	   });
	 * ```
	 */
	getBlockTable(): McDbBlockTable;
	/**
	 * 得到图纸的字典对象。
	 * @returns McDbDictionary
	 * @example
	 * ```ts
	   import { MxCpp, McDbDatabase } from "mxcad"
	   // 写扩展记录
	   let mxcad = MxCpp.getCurrentMxCAD();
	   let dict = mxcad.getDatabase().getNamedObjectsDictionary();

	   let sName = "MyDict";
	   let idDict = dict.getAt(sName);
	   if (idDict.isNull()) {
		   let newDict = new McDbDictionary;
		   idDict = dict.addObject(sName, newDict);
		}
		let myDict = idDict.getMcDbDictionary();
		if (myDict) {

			let xrec = new McDbXrecord();
			let data = new MxCADResbuf();
			data.AddString("TestData");
			xrec.setData(data);
			myDict.addObject("MyRecord", xrec);
			console.log("write xrecord ok");
		}
	 * ```
	 */
	getNamedObjectsDictionary(): McDbDictionary;
	/**
   * 得到对象所在组中的所有对象id
   * @returns McDbDictionary
   */
	getEntitiesInTheGroup(id: McObjectId): McObjectId[];
	/**
	* 得到图纸的组字典对象。
	* @returns McDbDictionary
	*/
	GetGroupDictionary(): McDbDictionary;
	/**
	 * 把一堆对象创建一个组
	 * @returns boolean
	 * @example
	 * ```ts
	 async function Mx_Test_CreateGroup(){
		let ss = new MxCADSelectionSet();
		if (!await ss.userSelect("选择要做成组的对象:")) return;
		if (ss.count() == 0) return;
		let mxcad = MxCpp.getCurrentMxCAD();
		mxcad.getDatabase().CreateGroup(ss.getIds(),"GroupName");

		let idGroup = mxcad.database.GetGroupDictionary().getAt("GroupName");
		let group = idGroup.getMcDbGroup();
		if(group){
			console.log(group.getAllEntityId());
		}
	 }
	 * ```
	 */
	CreateGroup(ids: McObjectId[], name?: string): boolean;
	/**
	 * 获取块表
	 */
	get blockTable(): McDbBlockTable;
	/**
	 *返回当前空间块表记录
	 * @returns 块表记录
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 *
	 * //获取当前图纸的实际显示范围
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * const {minPt, maxPt} = mxcad.getDatabase().currentSpace.getBoundingBox();
	 * ```
	 */
	get currentSpace(): McDbBlockTableRecord;
	/**
	 *返回当前空间块表记录id
	 * @returns 块表记录id

	 */
	get currentSpaceId(): McObjectId;
	/**
	 *返回模型空间块表记录id
	 * @returns 模型块表记录id

	 */
	get modelSpaceId(): McObjectId;
	/**
	 *返回0层id
	 * @returns 0层id

	 */
	get zeroLayerId(): McObjectId;
	/**
	 *返回0层id
	 * @returns 0层id

	 */
	get isCurrentModelSpace(): boolean;
	/**
	 * 获取当前线型比例。
	 * @returns 当前线型比例。
	 */
	getCurrentlyLineTypeScale(): number;
	/**
	 * 设置当前线型比例。
	 * @param val 线型比例。
	 * @returns 当前线型比例。
	 */
	setCurrentlyLineTypeScale(val: number): number;
	/**
	 * 获取当前线型名称。
	 * @returns 当前线型名称。
	 */
	getCurrentlyLineTypeName(): string;
	/**
	 * 设置当前线型名称。
	 * @param sName 线型名称。
	 */
	setCurrentlyLineTypeName(sName: string): void;
	/**
	 * 获取当前层名称。
	 * @returns 当前层名称。
	 */
	getCurrentlyLayerName(): string;
	/**
	 * 设置当前层名称。
	 * @param sName 层名称。
	 */
	setCurrentlyLayerName(sName: string): void;
	/**
	 * 获取当前CAD颜色。
	 * @returns 当前CAD颜色。
	 */
	getCurrentlyTrueColor(): McCmColor;
	/**
	 * 获取当前绘图使用的颜色
	 */
	getCurrentlyDrawColor(): THREE.Color;
	/**
	 * 设置当前CAD颜色。
	 * @param color CAD颜色。
	 */
	setCurrentlyTrueColor(color: McCmColor): any;
	/**
	 * 获取当前颜色索引。
	 * @returns 当前颜色索引（ColorIndexType）。
	 */
	getCurrentlyColorIndex(): number;
	/**
	 * 设置当前颜色索引（ColorIndexType）。
	 * @param colorIndex 颜色索引。
	 */
	setCurrentlyColorIndex(colorIndex: number): any;
	/**
	 * 获取当前文字样式名称。
	 * @returns 当前文字样式名称。
	 */
	getCurrentlyTextStyleName(): string;
	/**
	 * 设置当前文字样式名称。
	 * @param sName 文字样式名称。
	 */
	setCurrentlyTextStyle(sName: string): void;
	/**
	* 返回当前使用的线重.
	*/
	getCurrentlyLineWeight(): McDb.LineWeight;
	/**
	* 设置当前使用的线重.
	*/
	setCurrentlyLineWeight(lineWeight: McDb.LineWeight): void;
	/**
	* 返回当前文字样式id.
	*/
	getCurrentlyTextStyleId(): McObjectId;
	/**
	* 设置当前文字样式id.
	*/
	SetCurrentlyTextStyleId(id: McObjectId): boolean;
	/**
	* 返回当前标注样式id.
	*/
	getCurrentlyDimStyleId(): McObjectId;
	/**
	* 设置当前标注样式id.
	*/
	setCurrentlyDimStyleId(id: McObjectId): boolean;
	/**
	  * 返回当前层id.
	  */
	getCurrentlyLayerId(): McObjectId;
	/**
	* 设置当前标注样式id.
	*/
	setCurrentlyLayerId(id: McObjectId): boolean;
	/**
	 * 返回当前线型id.
	 */
	getCurrentlyLinetypeId(): McObjectId;
	/**
	* 设置当前标注样式id.
	*/
	setCurrentlyLinetypeId(id: McObjectId): boolean;
	/**
	 * 根据对象的句柄返回对象id.
	 * @example
	 * ```ts
	 * import { MxCpp, McDbDatabase } from "mxcad"
	 *
	 * const dataBase:McDbDatabase = MxCpp.getCurrentMxCAD().getDatabase();
	 * // 传入句柄并获取相应的对象 ID
	 * const handle = "ABCD1234"; // 假设这是一个有效的句柄
	 * const objectId = dataBase.handleToIdIndex(handle);
	 * // 确保获取的对象 ID 是有效的
	 * if (objectId) {
	 *   console.log("success", objectId);
	 * } else {
	 *   console.log("error")
	 * }
	 * ```
	 */
	handleToIdIndex(sHandle: string): McObjectId;
	/**
	 * 当前数据库是否被修改
	 * @return 返回布尔值
	 * @example
	 * ```ts
	 * import { MxCpp, McDbDatabase } from "mxcad"
	 *
	 * const dataBase:McDbDatabase = MxCpp.getCurrentMxCAD().getDatabase();
	 * const res = dataBase.isModifyed();
	 * if(res){
	 *   console.log("已修改")
	 * }else{
	 *   console.log("未修改")
	 * }
	 * ```
	 */
	isModifyed(): boolean;
	/**
	 * 把当前数据库修改状态重置成未修改状态
	 */
	resetModificationStatus(): void;
}
/**
 * McDbBlockTableRecord 是块表记录对象，用于管理图块定义中的实体集合、基点和块属性。
 *
 * @description
 * 该类表示 CAD 中的一个块定义记录，主要用于维护块内部的实体内容、块基点和块名称。
 * 通过它可以完成：
 * - 向块中添加实体对象；
 * - 获取块中所有实体的对象 ID；
 * - 设置块的基点、边界框和名称；
 * - 作为块参照的定义来源，后续可通过 McDbBlockReference 进行显示和插入。
 *
 * 使用方法总结：
 * 1. 创建 McDbBlockTableRecord 实例；
 * 2. 调用 appendAcDbEntity() 将实体加入块中；
 * 3. 通过 origin、name 等属性设置块的基点和名称；
 * 4. 将该块记录添加到块表中，再用 McDbBlockReference 创建块参照显示。
 *
 * @example
 * ```ts
	// 添加图块
	import { MxCpp, McDbBlockTableRecord, McDbBlockReference, McDbLine, McCmColor } from "mxcad"

	let mxcad = MxCpp.getCurrentMxCAD();
	let blkTable =  mxcad.getDatabase().getBlockTable();
	let blkRecId = blkTable.add(new McDbBlockTableRecord());

	// 根据ObjectId再次得到刚刚添加的图块记录
	let blkTableRecord:McDbBlockTableRecord = blkRecId.getMcDbBlockTableRecord()

	// 添加两条线段再图块记录中 这里每条线段的具体属性比如开始点和结束点自行赋值
	const line = new McDbLine(80, 80, 0, -80, -80, 0)
	line.trueColor = new McCmColor(255, 0, 0)
	const line1 = new McDbLine(-80, 80, 0, 80, -80, 0)
	blkTableRecord.appendAcDbEntity(line);
	blkTableRecord.appendAcDbEntity(line1);

	// 设置图块的基点 一般是包围盒内的点， 可以任意指定
	blkTableRecord.origin = new McGePoint3d(0,0,0);

	// 实例化块参照 这里需要设置我们刚刚添加图块记录得到的ObjectId
	let blkRef = new McDbBlockReference();
	blkRef.blockTableRecordId = blkRecId;
	// 最后设置位置 渲染图块
	blkRef.position = new McGePoint3d(0,0,0);

	mxcad.drawEntity(blkRef);
 * ```
 * ```ts
	// 改块颜色
	import { McDbBlockTableRecord, MxCADResbuf, MxCpp, McCmColor} from "mxcad";
	
	// 选择块对象并修改其颜色。
	async function Mx_BlkColor() {
		// 选择目标块
		let filter = new MxCADResbuf();
		filter.AddMcDbEntityTypes("INSERT");// 设置过滤器，选择块对象
		const getBlockEvent = new MxCADUiPrEntity()
		getBlockEvent.setMessage('选择需要修改基点的块');
		getBlockEvent.setFilter(filter);
		const block_id = await getBlockEvent.go();
		if (!block_id.id) return;
		// 块实体
		const blkRef = block_id.getMcDbEntity() as McDbBlockReference;
		let blkRec = blkRef.blockTableRecordId.getMcDbBlockTableRecord();
		Mx_ModyfBlockRecordEntityColor(blkRec);// 设置块颜色类型为随块

		// 设置块颜色
		const getColor = new MxCADUiPrInt();
		getColor.setMessage('输入颜色索引(0~256)');
		let colorNum = await getColor.go() || 0;
		let color = new McCmColor();
		color.setColorIndex(colorNum);
		blkRef.trueColor = color;
		const mxcad = MxCpp.getCurrentMxCAD();
		mxcad.updateDisplay()
	}
	// 设置块颜色类型
	function Mx_ModyfBlockRecordEntityColor(blkRec: McDbBlockTableRecord) {
		blkRec.getAllEntityId().forEach(id => {
			let ent = id.getMcDbEntity();
			ent.colorIndex = ColorIndexType.kByblock;
			if (ent instanceof McDbBlockReference) {
				let blkref = ent as McDbBlockReference;
				Mx_ModyfBlockRecordEntityColor(blkref.blockTableRecordId.getMcDbBlockTableRecord());
			}
		})
	}
 * ```
 */
export declare class McDbBlockTableRecord extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 给图块添加对应实体
	 * @param pEntity 实体
	 * @returns 对象id
	 */
	appendAcDbEntity(pEntity: McDbEntity): McObjectId;
	/**
	 * 获取图块中所有实体的对象ID
	 */
	getAllEntityId(skipDeleted?: boolean): McObjectId[];
	/**
	 * 返回块表记录中所有对象的最小，最大显示顺序.
	 * @return { object } minDrawOrder: 最小显示顺序 | maxDrawOrder: 最大显示顺序
	 */
	getMinMaxDrawOrder(): {
		minDrawOrder: number;
		maxDrawOrder: number;
	};
	/**
	 * 图块原点
	 * @return 三维点向量
	 */
	get origin(): McGePoint3d;
	set origin(origin: McGePoint3d);
	/**
	 * 得到图块最小外包，获取图块的最大点和最小点
	 * @returns { object }  minPt:最小点 | maxPt:最大点 | ret:是否获取成功
	 */
	getBoundingBox(): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 使边界框缓冲区无效化，强制重新计算或更新边界框信息
	 */
	invalidBoundingBoxBuffer(): void;
	/**
	 * 获取或设置名称。
	 */
	get name(): string;
	set name(val: string);
}
/**
 * McDbBlockTable 是数据库中的块表，负责管理当前图纸中的所有块定义。
 *
 * @description
 * 该类用于维护和访问图纸中的块定义集合，包括遍历、添加、查找和判断块记录是否存在。
 * 通过它可以完成：
 * - 获取全部块记录 ID；
 * - 新增命名块定义；
 * - 按名称查找块记录；
 * - 判断块是否存在；
 * - 为后续块插入和块引用提供入口。
 *
 * 使用方式：
 * 1. 通过数据库获取块表 `MxCpp.getCurrentMxCAD().getBlockTable()`；
 * 2. 调用 getAllRecordId() 查看全部块表记录对象；
 * 3. 使用 add() / get() / has() 管理块定义；
 * 4. 从返回的 McObjectId 中获取 McDbBlockTableRecord 继续编辑块内容。
 *
 * 总结：在实际开发中，McDbBlockTable 是块管理的核心入口，适合创建和检索图块定义，支撑块插入和动态块开发。
 *
 * @example
 * ```ts
 * //遍历图纸中的所有图块
 * import { MxCpp, McDbBlockTable } from "mxcad"
 *
 * // 获取当前cad对象
 * let mxcad = MxCpp.getCurrentMxCAD();
 * // 获取块表对象
 * let blockTable: McDbBlockTable = mxcad.getDatabase().getBlockTable();
 * // 获取块表中的所有记录对象id
 * let aryId = blockTable.getAllRecordId();
 * //遍历记录对象id，获取块表记录对象详情
 * aryId.forEach((id) => {
 * let blkRec = id.getMcDbBlockTableRecord();
 * if (blkRec === null) return;
 *     console.log(blkRec);
 *     console.log("blkRec.name:" + blkRec.name);
 *     console.log("blkRec.origin:" + blkRec.origin);
 * });
 * ```
 */
export declare class McDbBlockTable extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取块表中的所有图块记录的ID。
	 * @param skipDeleted 是否跳过已删除图块记录。
	 * @returns ret 图块记录ID数组。
	 */
	getAllRecordId(skipDeleted?: boolean): McObjectId[];
	/**
	 * 向块表中添加图块记录。
	 * @param rec 图块记录对象。
	 * @returns 新增图块记录对象ID。
	 * @example
	 * ```ts
	 * import { MxCpp, McDbBlockTable } from "mxcad"
	 *
	 * let mxcad = MxCpp.App.getCurrentMxCAD();
	 * let blockTable: McDbBlockTable = mxcad.getDatabase().getBlockTable();
	 * const blkRec = new McDbBlockTableRecord();
	 * const objId = blockTable.add(blkRec);
	 * ```
	 */
	add(rec: McDbBlockTableRecord | string): McObjectId;
	/**
	 * 查找块表中的图块记录。
	 * @param sName 图块记录名称。
	 * @param skipDeleted 是否跳过已删除图块记录。
	 * @returns 图块记录对象ID。
	 */
	get(sName: string, skipDeleted?: boolean): McObjectId;
	/**
	 * 检查块表中是否存在指定名称的图块记录。
	 * @param sName 图块记录名称。
	 * @param skipDeleted 是否跳过已删除图块记录。
	 * @returns 布尔值。
	 */
	has(sName: string): boolean;
}
/**
 * McDbRasterImageDef 是光栅图像定义对象，用于描述 CAD 中的图片资源定义和图像文件路径。
 *
 * @description
 * 该类用于管理光栅图像的来源文件、图像数据以及图像存储方式。
 * 通过它可以完成：
 * - 绑定和读取光栅图像文件路径；
 * - 保存图像为 Base64 数据；
 * - 作为图像定义对象提供给 CAD 的图像实体使用。
 *
 * 使用方式：
 * 1. 创建 McDbRasterImageDef 实例；
 * 2. 设置 sourceFileName；
 * 3. 通过 saveToBase64() 生成可传输的图片数据；
 * 4. 进一步用于图像实体显示和图纸集成。
 *
 * 总结：在实际开发中，McDbRasterImageDef 是光栅图像资源的定义层，适用于嵌入、显示和传输图像数据。
 *
 * @example
 * ```ts
 * import { McDbRasterImageDef } from "mxcad";
 *
 * // 创建并配置栅格图像定义对象。
 * async function testRasterImageDef() {
 *   const imageDef = new McDbRasterImageDef();
 *   imageDef.sourceFileName = "https://cdn.pixabay.com/photo/2022/11/15/12/23/winter-7593872_960_720.jpg";
 *   const base64 = imageDef.saveToBase64(imageDef.sourceFileName);
 *   console.log("保存 Base64 成功:", base64);
 * }
 * ```
 */
export declare class McDbRasterImageDef extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取或设置栅格图像文件的路径。
	 * @param sPathName 文件的路径
	 */
	set sourceFileName(sPathName: string);
	get sourceFileName(): string;
	/**
	 * 将栅格图像保存为 Base64 编码的字符串
	 * @param sUrl 格栅图像路径
	 * @returns 布尔值
	 */
	saveToBase64(sUrl: string): boolean;
}
/**
 * McDbDictionary 是数据库中的命名字典对象，用于存放键值映射关系，以及嵌套字典和扩展记录数据。
 *
 * @description
 * 该类可视为一个键值映射表，将字符串名称映射到对象实例，用于保存图纸中的自定义数据、扩展数据和字典嵌套结构。
 * 通过它可以完成：
 * - 获取所有对象名和对象 ID；
 * - 向字典中新增对象；
 * - 按名称查找和删除对象；
 * - 嵌套保存多个字典和扩展记录；
 * - 扩展图纸数据模型。
 *
 * 使用方式：
 * 1. 从数据库中获取命名对象字典 `MxCpp.getCurrentMxCAD().getDatabase().getNamedObjectsDictionary()`；
 * 2. 调用 addObject()、getAt()、remove() 管理键值；
 * 3. 继续通过对象 ID 获取具体的字典或扩展记录对象；
 * 4. 用于自定义数据存储和扩展数据管理。
 *
 * 总结：在实际开发中，McDbDictionary 是图纸自定义数据存储和扩展信息管理的核心容器，适合保存各种命名对象和嵌套字典。
 *
 * @example
 * ```ts
 * import { McDbDictionary, McDbXrecord } from "mxcad"
 *
 * //遍历字典
 * // 获取数据库中的命名对象字典内容。
 * function MxTest_GetNamedObjectsDictionary() {
 *   // 获取当前CAD对象
 *   let mxcad = MxCpp.getCurrentMxCAD();
 *   // 获取数据库中的字典对象
 *   let dict = mxcad.getDatabase().getNamedObjectsDictionary();
 *   // 获取字典中所有的对象名
 *   let aryName = dict.getAllObjectName();
 *   // 遍历对象名
 *   aryName.forEach((name) => {
 *     console.log(name);
 *     let id = dict.getAt(name);
 *     let obj = id.getMcDbObject();
 *     if (obj instanceof McDbDictionary) {
 *       let dict: McDbDictionary = obj;
 *       console.log(dict);
 *       MxTest_DictionaryData(dict);// 递归遍历字典对象
 *     }
 *   })
 * }
 *
 * function MxTest_DictionaryData(dict: McDbDictionary) {
 *   let aryName = dict.getAllObjectName();
 *   aryName.forEach((name) => {
 *     console.log(name);
 *     let id = dict.getAt(name);
 *     let obj = id.getMcDbObject();
 *     if (obj instanceof McDbDictionary) {
 *       let dict: McDbDictionary = obj;
 *       console.log(dict);
 *       MxTest_DictionaryData(dict);
 *     }
 *     else if (obj instanceof McDbXrecord) {
 *       let xrec: McDbXrecord = obj;
 *       let data = xrec.getData()
 *       data.PrintData();
 *     }
 *   })
 * }
 * ```
 */
export declare class McDbDictionary extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 获取字典中的所有对象。
	 * @returns 对象ID数组
	 */
	getAllObject(): McObjectId[];
	/**
	 * 获取字典中所有的对象名。
	 * @returns 对象名数组
	 * @example
	 * ```ts
	 * import { MxCpp, McDbDictionary } from "mxcad";
	 *
	 * let mxcad = MxCpp.getCurrentMxCAD();
	 * let dict:McDbDictionary = mxcad.getDatabase().getNamedObjectsDictionary();
	 * const aryName = dict.getAllObjectName();
	 * console.log(aryName);
	 * ```
	 */
	getAllObjectName(): McGeStringArray;
	/**
	 * 移除指定对象
	 * @param sName 对象名称
	 * @returns 布尔值
	 */
	remove(sName: string): boolean;
	/**
	 * 向字典中添加对象
	 * @param sName 对象名称
	 * @param obj 对象
	 * @returns 对象ID
	 */
	addObject(sName: string, obj: McDbObject): McObjectId;
	/**
	 * 获取字典中指定对象
	 * @param sName 对象名称
	 * @param isGetErased 是否获取已删除的对象
	 * @returns 对象ID
	 */
	getAt(sName: string, isGetErased?: boolean): McObjectId;
	/**
	* 修改字典中key的值，到新的值，如果新的值，在字典中已经存在，就会设置失败。
	* sNewName为空，会自动创建一个匿名名称。
	* @returns 是否成功
	*/
	setName(sOldName: string, sNewName: string): boolean;
}
/**
 * McDbXrecord 是扩展记录对象，用于为实体或字典附加自定义扩展数据。
 *
 * @description
 * 该类用于存放附加信息，能够把 resbuf 数据挂接到对象上，以保存更多业务参数和自定义字段。
 * 通过它可以完成：
 * - 设置扩展记录数据；
 * - 读取扩展记录数据；
 * - 将自定义属性写入实体或字典对象；
 * - 在对象中保留业务场景所需的附加信息。
 *
 * 使用方式：
 * 1. 创建 McDbXrecord 实例；
 * 2. 使用 MxCADResbuf 组装数据；
 * 3. 调用 setData() 写入；
 * 4. 通过 getData() 读取扩展信息。
 *
 * 总结：在实际开发中，McDbXrecord 是图纸对象附加自定义数据的标准方式，适合存储业务属性和扩展信息。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbDictionary, McDbXrecord, MxCADResbuf } from "mxcad";
 *
 * // 创建并操作扩展记录 Xrecord。
 * async function testXrecord() {
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const dict = mxcad.getDatabase().getNamedObjectsDictionary();
 *   const xrec = new McDbXrecord();
 *   const data = new MxCADResbuf();
 *   data.AddString("demo");
 *   xrec.setData(data);
 *   dict.addObject("MyRecord", xrec);
 * }
 * ```
 */
export declare class McDbXrecord extends McDbObject {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	 * 设置扩展记录中的数据。
	 * @param xdata resbuf 数据
	 */
	setData(xdata: MxCADResbuf): boolean;
	/**
	  * 获取扩展记录中的数据。
	  * @param xdata resbuf 数据
	  */
	getData(): MxCADResbuf;
}
/**
 * McDbGroup 是图纸中的分组对象，用于把多个对象组织成一个逻辑集合。
 *
 * @description
 * 该类用于管理一组对象的整体选择、命名和描述信息，便于对多个对象进行统一处理。
 * 通过它可以完成：
 * - 创建一组对象集合；
 * - 设置组名和描述；
 * - 控制组是否可选；
 * - 通过数据库中的组字典保存和查询分组。
 *
 * 使用方式：
 * 1. 先选择多个对象；
 * 2. 调用数据库的 CreateGroup() 创建组；
 * 3. 通过 name、description、isSelectable 控制组属性；
 * 4. 后续按组对象执行整体管理或选择处理。
 *
 * 总结：在实际开发中，McDbGroup 是对象分组管理的核心类型，适合实现批量处理、统一选择和组织管理。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbGroup, MxCADSelectionSet } from "mxcad";
 *
 * // 创建并管理图形分组对象。
 * async function testGroup() {
 *   const ss = new MxCADSelectionSet();
 *   const ok = await ss.userSelect("选择要分组的对象");
 *   if (!ok) return;
 *
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const group = new McDbGroup();
 *   group.name = "MyGroup";
 *   group.description = "测试分组";
 *   mxcad.getDatabase().CreateGroup(ss.getIds(), group.name);
 * }
 * ```
 */
export declare class McDbGroup extends McDbObject {
	/**
	* 构造函数。
	*/
	constructor(imp?: any);
	/**
	 * 说明内容
	 */
	set description(description: string);
	get description(): string;
	/**
	 * 组名
	 */
	set name(name: string);
	get name(): string;
	/**
	 * 是否选择操作
	 */
	set isSelectable(val: boolean);
	get isSelectable(): boolean;
	/**
	  * 清空组
	  */
	clear(): boolean;
	/**
	 * 向组添加对象
	 */
	append(id: McObjectId): boolean;
	/**
	 * 向组添加对象数组
	 */
	appendArray(aryId: McObjectId[]): boolean;
	/**
	  *组中是否有该对象
	  */
	has(id: McObjectId): boolean;
	/**
	  *得到组中所有对象
	  */
	getAllEntityId(): McObjectId[];
	/**
	  *得到组中所有对象数量
	  */
	numEntities(): number;
}
declare class MxAI {
	private serverUrl;
	private mapFun;
	init(serverUrl: string): void;
	addFunction(name: string, call: any): void;
	registTool(tool: any): void;
	reloadTools(param: any): void;
	chat_tool(str: string): void;
}
/** 排除接口包含某些类型的属性名称 */
export type NonPropertyNames<T, P> = {
	[K in keyof T]: T[K] extends P ? never : K;
}[keyof T];
/** 排除接口包含某些类型的属性
 * @param T 需要排除类型的接口
 * @param P 需要排除类型接口属性的类型
 * @example
 * ```ts
 * interface MyInterface {
 *  name: string;
 *  age: number;
 *  sayHello(): void;
 *  walk(distance: number): void;
 * }
 * ExcludePropertiesContainingThisType<MyInterface, Function>
 * ```
 */
export type ExcludePropertiesContainingThisType<T, P> = Pick<T, NonPropertyNames<T, P>>;
/** 颜色方法类型 */
export declare enum ColorMethod {
	/** 颜色随层 */
	kByLayer = 1,
	/** 颜色随块 */
	kByBlock = 2,
	/** 颜色值 */
	kByColor = 3,
	/** 颜色索引值 */
	kByACI = 4,
	kByPen = 5,
	kForeground = 6,
	kLayerOff = 7,
	kLayerFrozen = 8,
	kNone = 9
}
/** 颜色索引类型 */
export declare enum ColorIndexType {
	/** 随块 */
	kByblock = 0,
	/** 红色 */
	kRed = 1,
	/** 黄色 */
	kYellow = 2,
	/** 绿色 */
	kGreen = 3,
	/** 青色 */
	KCyan = 4,
	/** 蓝色*/
	kBlue = 5,
	/** 洋红色*/
	kMagenta = 6,
	/** 白色(反色)*/
	kWhite = 7,
	/** 随层 */
	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) => import("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 属性类型
 */
export declare enum FetchAttributes {
	/** 将获取的数据加载到内存中 */
	EMSCRIPTEN_FETCH_LOAD_TO_MEMORY = 1,
	/** 持久化文件 */
	EMSCRIPTEN_FETCH_PERSIST_FILE = 4,
	/** 追加数据 */
	EMSCRIPTEN_FETCH_APPEND = 8,
	/** 替换数据 */
	EMSCRIPTEN_FETCH_REPLACE = 16
}
/**
 * 临时图形绘制管理器 (McObjectTempDraw)
 *
 * @description
 * 该类用于在 CAD 视图上进行高性能的临时图形绘制（Overlay）。
 * 核心特点是“只读不写”：它允许你在屏幕上绘制图形（如高亮、辅助线、动态反馈），
 * 但不会将这些图形实际保存到图形数据库中。常用于实现鼠标悬停高亮、拖拽预览或临时测量显示。
 *
 * 使用方法总结：
 * 1. 通过 `MxCpp.mxcad.getTempDraw()` 获取临时图形绘制对象；
 * 2. 调用 `readyMcDbEntitysWorldDraw()`、`setDrawColor()` 等方法准备绘制上下文；
 * 3. 调用 `worldDrawMcDbEntitys()` 进行临时绘制，完成后使用 `endMcDbEntitysWorldDraw()` 结束绘制。
 *
 * @example
 * // 场景：选中实体后，将其临时加粗并变红显示（高亮效果）
 * import { MxCADUtility, MxCpp } from "mxcad";
 *
 * async function highlightSelectedEntity() {
 *   // 1. 获取用户选择的实体 ID
 *   const retIds = await MxCADUtility.selectEnt("选择加粗显示对象");
 *   if (retIds.length == 0) return;
 *
 *   const ent = retIds[0].getMcDbEntity();
 *   if (!ent) return;
 *
 *   // 2. 获取临时绘制上下文
 *   const mxcad = MxCpp.getCurrentMxCAD();
 *   const tempDraw = mxcad.getTempDraw();
 *
 *   // 3. 配置绘制样式（红色、线宽 0.60mm）
 *   tempDraw.clearAll(); // 清除旧绘制
 *   tempDraw.readyMcDbEntitysWorldDraw(); // 准备上下文
 *   tempDraw.setDrawColor(0xFF0000, 0xFF0000); // 设置颜色
 *   tempDraw.setLineWeightDisplay(true, McDb.LineWeight.kLnWt060); // 设置线宽
 *
 *   // 4. 执行绘制
 *   tempDraw.worldDrawMcDbEntitys(ent as any);
 *
 *   // 5. 结束绘制上下文
 *   tempDraw.endMcDbEntitysWorldDraw();
 * }
 *
 * @note
 * 1. 绘制的内容仅存在于当前视图帧，刷新或重绘后可能会消失，需重新调用。
 * 2. 务必成对调用 `readyMcDbEntitysWorldDraw` 和 `endMcDbEntitysWorldDraw` 以确保资源正确释放。
 */
export declare class McObjectTempDraw {
	private imp;
	/**
	 * 构造函数
	 * @param imp 对象实现
	 */
	constructor(imp: any);
	/**
	 * 清除所有临时绘制内容
	 * @description 移除当前视图上所有通过此类绘制的临时图形。
	 */
	clearAll(): void;
	/**
	 * 释放对McDbEntitys的临时绘制上下文。
	 */
	freeMcDbEntitysDisplay(): void;
	/**
	 * 准备对McDbEntitys的临时绘制上下文。
	 */
	readyMcDbEntitysWorldDraw(): void;
	/**
	 * 结束对McDbEntitys的临时绘制的上下文，释放资源。
	 */
	endMcDbEntitysWorldDraw(): void;
	/**
	* 清除McDbEntitys临时绘制的数据
	*/
	clearMcDbEntitysDisplay(): void;
	/**
	* 生成McDbEntitys临时绘制的数据
	* @param ent McDbEntity对象
	*/
	worldDrawMcDbEntitys(ent: McDbEntity): boolean;
	/**
	 * 禁用McDbEntitys临时绘制的OpenGL的DepthTest
	 * @param isDisable 是否禁用深度测试，默认为true
	 */
	disableDepthTestMcDbEntitysDisplay(isDisable?: boolean): void;
	/**
	 * 启用线重的显示。
	 * @param val 是否启用线重显示
	 * @param iGlobalLineweight 全局线宽，默认为-1表示使用默认线宽
	 */
	setLineWeightDisplay(val?: boolean, iGlobalLineweight?: number): void;
	/**
	 * 添加临时绘制线条数据
	 * @param vecLinePoints 线条点数组
	 */
	addLines(vecLinePoints: McGePoint3dArray): void;
	/**
	 * 添加临时绘制填充三角形数据
	 * @param vecTrianglesPoints 三角形点数组
	 */
	addTriangles(vecTrianglesPoints: McGePoint3dArray): void;
	/**
	 * 清除临时绘制数据
	*/
	clear(): void;
	/**
	 * 设置显示顺序
	 * @param iDrawOrder 绘制顺序
	 * @param iMcDbEntityDrawOrder McDbEntity的绘制顺序
	*/
	setDrawOrder(iDrawOrder: number, iMcDbEntityDrawOrder: number): void;
	/**
	* 设置Draw颜色
	* @param color 颜色值
	* @param iMcDbEntityDrawColor McDbEntity的绘制颜色
   */
	setDrawColor(color: number, iMcDbEntityDrawColor?: number): void;
}
declare class McRxObjectImp {
}
/**
 * McObject 是 MxCAD 的主控对象，负责承接 CAD 应用实例的核心能力。
 * @description
 * 这个类不是普通的实体对象，而是整个 MxCAD 运行时的“控制器/入口”。
 * 通过它可以完成：
 * - 获取当前 CAD 实例并操作图形数据库；
 * - 注册和处理各种事件（如选择变化、文件打开完成、数据库修改）；
 * - 调用绘图、重绘、坐标转换、临时显示等能力；
 * - 设置全局显示和运行参数。
 *
 * 使用方式：
 * 1. 先通过 MxCpp.getCurrentMxCAD() 或 MxCpp.mxcad 获取当前CAD实例；
 * 2. 再调用其方法进行绘图、交互或状态监听；
 * 3. 若需要创建新的独立实例，则先 new McObject()，再调用 create(config) 初始化。
 *
 * @example
 * ```ts
 * import { MxCpp } from "mxcad";
 *
 * const mxcad = MxCpp.getCurrentMxCAD();
 *
 * // 读取当前打开文件名
 * console.log(mxcad.currentFileName);
 *
 * // 注册选择变化事件
 * mxcad.on("selectChange", (ids) => {
 *   console.log("选中对象数：", ids.length);
 * });
 * ```
 *
 * @remarks
 * 适用场景包括：
 * - 二次开发插件：监听对象选择、文件打开、数据库变化；
 * - 自定义绘制：临时高亮、动态预览、辅助标注；
 * - 图形操作：添加/修改实体、重绘视图、控制显示参数；
 * - 交互开发：与 MxDraw、MxCAD 事件体系对接。
 */
export declare class McObject {
	/** 内部对象实现 */
	private imp;
	private cooperate;
	/** 内部事件 */
	private event;
	/** 当前打开的文件名 */
	private currentFileName;
	/** 当前打开的原始文件名 */
	private currentOriginalFileName;
	/** 是否是第一次打开文件 */
	private firstTimeOpenFile;
	/** 正式程序授权服务访问地址 */
	private authorized_service;
	/** 是否已初始化 MxObject */
	private isInitMxObject;
	/**
	 * 创建 McObject 实例。
	 *
	 * 该构造函数通常只在你需要手动创建一个独立实例时使用。
	 * 如果只是要操作当前正在运行的 CAD 窗口，优先使用 MxCpp.getCurrentMxCAD() 或 MxCpp.mxcad。
	 *
	 * @param imp 底层实现对象；通常由系统自动注入，开发者一般不需要手动传入。
	 */
	constructor(imp?: any);
	/**
	* @internal
	*/
	protected creaeCallId(): number;
	/** cad坐标转绘图修正的小坐标系
	  * @param pt 点的对象
	  */
	cadToSmallcoord(pt: McGePoint3d): McGePoint3d;
	/** 绘图修正的小坐标系转cad坐标
	 * @param pt 点对象
	 * @returns 转换后的点坐标
	 */
	smallcoordToCad(pt: McGePoint3d): McGePoint3d;
	/**
	 * 视区坐标到CAD坐标
	 * @param pt 点对象
	 * @returns 转换后的点坐标
	 */
	viewCoord2Cad(pt: McGePoint3d): McGePoint3d;
	/**
	 * cad坐标到视区坐标
	 * @param pt 点对象
	 * @returns 转换后的点坐标
	 */
	cadCoord2View(pt: McGePoint3d): McGePoint3d;
	/**
	 *CAD长度到视区长度
	 * @param l CAD长度
	 * @returns 视区长度
	 */
	cadCoordLong2View(l: number): number;
	/**
		*视区长度到CAD长度
		* @param l 视区长度
		* @returns CAD长度
	 */
	viewCoordLong2Cad(l: number): number;
	/**
	 * 获取临时绘制管理器。
	 *
	 * 这个方法返回的对象用于在当前视口上进行“临时绘制”，例如高亮选中对象、显示拖拽预览、动态测量提示等。
	 * 它的特点是只在视图中显示，不会真正写入图形数据库，因此适合做 UI 反馈和辅助显示。
	 *
	 * @returns 临时绘制对象，调用其 addLines / addTriangles / setDrawColor 等方法即可。
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 *
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * const tempDraw = mxcad.getTempDraw();
	 * tempDraw.clearAll();
	 * tempDraw.setDrawColor(0xFF0000);
	 * tempDraw.addLines(new McGePoint3dArray([new McGePoint3d(0, 0, 0), new McGePoint3d(100, 100, 0)]));
	 * ```
	 */
	getTempDraw(): McObjectTempDraw;
	/**
	 * 返回协同工作对象
	*/
	getCooperate(): MxCooperate;
	/**
	 * 判断层是不是一个在使用的有用层，删除一个层之前调用该函数判断一下。
	 * @param layerName 层名
	 * @returns true: 有用层，false: 无用层
	*/
	isUselessLayer(layerName: string): boolean;
	/**
	 * 重绘块表记录中的对象，在修改了块表记录中的对象后，显示效果没有及时更新时，需要调用一下这个函数。
	 * @param idBlockRecord 块表记录对象
	 * @returns boolean
	*/
	regenBlockRecord(idBlockRecord: McObjectId): boolean;
	/**
	 * 设置全局显示和运行属性。
	 *
	 * 通过这个方法可以控制一些影响用户体验或运行行为的参数，常见用途包括：
	 * - 打开/关闭撤销回退；
	 * - 控制坐标轴显示；
	 * - 调整显示精度；
	 * - 切换黑白显示模式。
	 *
	 * @param val 属性配置对象，支持以下常见项：
	 * 1. DisplayPrecision：number 显示精度，取值 0 ~ 1000，数值越大越精细；
	 * 2. EnableUndo：boolean 是否启用撤销/重做；
	 * 3. ShowCoordinate：boolean 是否显示 XY 坐标轴；
	 * 4. BlackWhiteDisplay：boolean 是否启用黑白显示。
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 * //获取当前MxCAD对象
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * //设置全局属性：打开撤销功能并显示坐标轴
	 * mxcad.setAttribute({ EnableUndo: true, ShowCoordinate: true });
	 * ```
	 */
	setAttribute(val: object): boolean;
	/**
	 * 返回与MxCAD对象绑定的MxDraw对象。
	 * @returns MxDraw对象
	 */
	getMxDrawObject(): MxDrawObject;
	/**
	 * 返回与MxCAD当前视区旋转矩阵
	 * @returns McGeMatrix3d对象
	 */
	getMxCADViewSpinMatrix(): McGeMatrix3d;
	/**
	 * 返回与MxCAD对象绑定的MxDraw对象。
	 * @returns MxDraw对象
	 */
	get mxdraw(): MxDrawObject;
	/**
	 * 把mxcad设置当前的cad对象
	 */
	makeCurrent(): void;
	/**
	 * 获取内部实现对象
	 * @returns 内部实现对象
	 */
	getImp(): any;
	/**
	 * 初始对象
	 * @param imp 对象实现，默认该函数会被系统自动调用。
	 *
	 */
	init(imp: any): void;
	/**
	 * 创建并初始化一个 MxCAD 实例。
	 *
	 * 这个方法会根据传入的配置启动 CAD 运行时并完成初始化。
	 * 适用于你需要在页面中嵌入一个新的 CAD 容器、加载自定义文件、或者创建独立实例时使用。
	 * 如果只是操作当前页面已存在的 CAD 窗口，通常不需要手动调用此方法。
	 *
	 * @param config createMxCad 的初始化配置，通常包含 canvas、locateFile、fileUrl、fontspath 等信息。
	 * @example
	 * ```ts
	 * import { McObject } from "mxcad";
	 *
	 * const mxcad = new McObject();
	 * mxcad.create({
	 *   canvas: "#myCanvas",
	 *   locateFile: (fileName) => new URL(`/node_modules/mxcad/dist/wasm/2d/${fileName}`, import.meta.url).href,
	 *   fileUrl: new URL("../src/assets/test.mxweb", import.meta.url).href,
	 *   fontspath: new URL("node_modules/mxcad/dist/fonts", import.meta.url).href,
	 * });
	 * ```
	 */
	create(config: MxCadConfig): void;
	/** 监听对象选择事件
	 * @example
	 * ```ts
	 * import { MxCpp, McObject, McObjectId } from "mxcad"
	 *
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD();
	 * mxcad.on("selectChange", (ids: McObjectId[])=> {
	 *      if (ids.length == 0) return;
	 *      let id = ids[0]
	 *      let ent = id.getMcDbEntity()
	 *      if(!ent) return
	 *      console.log(ent.objectName)
	 * })
	 * ```
	 *  */
	on(name: "selectChange", fun: (ids: McObjectId[]) => void | ((ids: McObjectId[]) => void)[]): void;
	/** 监听文件完全打开 */
	on(name: "openFileComplete", fun: () => void): void;
	/**mxdraw mxcad程序已经加载，准备初始化cpp程序 */
	on(name: "init_cpp", fun: () => void): void;
	/**mxdraw mxcad程序已经加载，准备创建mxdraw对象时触发 */
	on(name: "init", fun: () => void): void;
	/**初化地图加载时调用，mxdad-app npm使用 */
	on(name: "init_map", fun: (init_param: {
		map: MxMap;
		plugin: MxCADPluginBase;
	}) => void): void;
	/**地图图层加载时调用，mxdad-app npm使用*/
	on(name: "map_style.load", fun: (map: MxMap) => void): void;
	/** mxdraw对象创建了,准备初始相关参数时触发 */
	on(name: "init_before_mxdraw", fun: (mxdraw: MxDrawObject) => void): void;
	/**mxdraw对象创建后触发 */
	on(name: "init_mxdraw", fun: (mxdraw: MxDrawObject) => void): void;
	/**mxcad对象创建后,已经准备完成时触发 */
	on(name: "init_mxcad", fun: (mxcad: McObject) => void): void;
	/** 监听数据库修改事件 */
	on(name: "databaseModify", fun: () => void): void;
	/** 系统变量被修改 */
	on(name: "sysVarChanged", fun: (name: string) => void): void;
	/** 图形数据库初始化 */
	on(name: "databaseInitialization", fun: () => void): void;
	/** 图层数据发生了变化 */
	on(name: "layerChanged", fun: () => void): void;
	/** 线型数据发生了变化 */
	on(name: "lineTypeChanged", fun: () => void): void;
	/** 对象被修改事件，默认不会通知，配制EnableObjectModificationEvent变量启用 status:1:删除，2：增加，0: 修改*/
	on(name: "objectModified", fun: (param: {
		cmd: string;
		entitys: {
			id: McObjectId;
			erase: boolean;
			status: number;
		}[];
	}) => void): void;
	/**
	 * 关闭事件监听
	 * @param name 监听事件名
	 * @param fun 监听事件
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 *
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD();
	 * // e:事件函数,这里指代在mxcad.on("selectChange", e)中注册的函数
	 * mxcad.off("selectChange", e);
	 * ```
	 */
	off(name: string, fun?: Function): void;
	/**
	 * 触发一个系统事件的调用
	 * @param name 事件名
	 * @param param 事件参数
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 *
	 * // 手动触发init事件
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD();
	 * mxcad.callEvent("init");
	 * ```
	 */
	callEvent(sEventName: string, param?: any): boolean;
	private synchronizeMxDrawEvent;
	/**
	 * 初始化对象模型
	 * @description
	 * @param mxObject 初始化{@link https://mxcadx.gitee.io/mxdraw_docs | mxdraw} 创建的绘图控件
	 */
	initMxObject(mxObject: any): void;
	/**
	 * 重绘图上所有对象，在调用ZoomAll,ZoomW后，因为是异步执行，可能需要延迟调用Regen才会启作用。
	 * @param delayTime 执行时间
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from 'mxcad'
	 *  const mxcad:McObject = MxCpp.getCurrentMxCAD()
	   //绘制一个带有宽度的圆
		mxcad.addLinetype("CircleLineType", "30,-5,7,-7");

		//设计当前线型为"CircleLineType"
		mxcad.drawLinetype = ("CircleLineType");

		mxcad.drawLineWidth = 40;

		mxcad.drawCircle(600, 800, 120);

		mxcad.zoomAll();
		mxcad.regen();
		mxcad.updateDisplay();
	 * ```
	 */
	regen(delayTime?: number): void;
	/**
	 * 显示全部
	 * @param autoRegen 是否在方法执行后自动执行重绘方法
	 */
	zoomAll(autoRegen?: boolean): boolean;
	/**
	 * 缩放当前显示范围，它是相对于当前显示范围进行缩放
	 * @param scale scale缩放比例
	 * @returns void
	 */
	zoomScale(scale: number): void;
	/**
	 * 把对象添加当前选择中
	 * @param id 对象id或者对象id数组
	 * @param isDisplayGrid 是否显示夹点，默认true
	 * @param fireSelectEvent 是否触发选择事件，默认true
	 * @returns void
	 * @example
	 * ```typescript
	 * import { MxCpp, McObject } from "mxcad"
	 * let mxcad:McObject = MxCpp.getCurrentMxCAD();
	 * let id = mxcad.drawLine(0,0,1000,1000);
	 * mxcad.addCurrentSelect(id);
	 * ```
	 */
	addCurrentSelect(id: McObjectId | McObjectId[], isDisplayGrid?: boolean, fireSelectEvent?: boolean): void;
	/**
	 * 清除当前所有选择
	*/
	clearMxCurrentSelect(): void;
	/**
	* 清除显示的夹点
	*/
	clearGripDisplay(): void;
	/**
	  * 把当前显示范围移到指定的显示范围
	  * @param minPt 坐标1 McGePoint3d
	  * @param maxPt 坐标2 McGePoint3d
	  * @param isWorld 默认为felse DWG图纸坐标，设置为true是THREEJS坐标
	  * @returns void
  */
	zoomW(minPt: McGePoint3d, maxPt: McGePoint3d): void;
	/**
	 * 把当前显示范围移到指定的位置,dCenX,dCenY是DWG图纸坐标。
	 * @param dCenX 视区中心点X坐标
	 * @param dCenY 视区中心点Y坐标
	 * @returns void
	 */
	zoomCenter(dCenX: number, dCenY: number): void;
	/**
	 * 设置显示视区的角度，单位是PI.
	 * @returns void
	 * @param viewangle 旋转角度 Math.PI
	 */
	zoomAngle(viewangle: number): void;
	/**
	 * 打开网络文件
	 * @param sFileUrl 网络文件路径
	 * @param retCall 回调函数，可选参数，打开文件完成后的回调函数，参数为打开文件的结果,0表示成功，其他值表示失败
	 * @param isWorkThread 是否使用工作线程打开文件，默认为 true
	 * @param obj_param: 打开参数，比如传一个请求头{requestHeaders:{aaa:"xxxxx"}}
	 * @param fetchAttributes 1：EMSCRIPTEN_FETCH_LOAD_TO_MEMORY,把图纸数据加载内存中，0:EMSCRIPTEN_FETCH_LOAD_TO_MEMORY | EMSCRIPTEN_FETCH_PERSIST_FILE | EMSCRIPTEN_FETCH_APPEND，把图纸数据加到IndexedDB。
	 * @returns 是否成功打开文件
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * mxcad.openWebFile("http://localhost:1337/mxcad/file/a9cbed3d3a351b79f24484e87bd78338.DWG.mxweb");
	 * ```
	 */
	openWebFile(sFileUrl: string, retCall?: (iRet: number) => void, isWorkThread?: boolean, obj_param?: object, fetchAttributes?: number, isFetchTzFile?: boolean): boolean;
	/**
	* 清空当前图上内容，新建一个文件
	*/
	newFile(): boolean;
	/**
	* 当回当前打开的文件的在md5码。
	*/
	getCurrentOpenFileMd5(): string;
	/**
	 * 插件图块文件
	 * @param sFileUrl 网络文件路径 该文件为mxweb格式
	 * @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 { McDbBlockReference, MxCADUiPrPoint, MxCpp } from "mxcad";
		// 插入图块
		async function MxTest_InsertBlock() {
			let baseUrl = "http://localhost:3000/mxcad/"
			// 设置图块路径
			let blkFilePath = baseUrl + "tree.mxweb";

			// 插入图块文件
			let mxcad = MxCpp.App.getCurrentMxCAD();
			let blkrecId = await mxcad.insertBlock(blkFilePath, "tree");
			if (!blkrecId.isValid()) {
				// 插入图块
				return;
			}

			// 设置图块大小
			let blkRef = new McDbBlockReference();
			blkRef.blockTableRecordId = blkrecId;
			let box = blkRef.getBoundingBox();
			if (box.ret) {
				let dLen = box.maxPt.distanceTo(box.minPt);
				if (dLen > 0.00001) {
					blkRef.setScale(mxcad.getMxDrawObject().screenCoordLong2Doc(100) / dLen);
				}
			}

			// 指定插入基点
			let getPoint = new MxCADUiPrPoint();
			getPoint.setMessage("\指定插入基点");

			// 动态绘制图块
			getPoint.setUserDraw((v, worldDraw) => {
				blkRef.position = v;
				worldDraw.drawMcDbEntity(blkRef);
			});

			let pt = await getPoint.go();
			if (!pt) return;
			blkRef.position = pt;
			// 绘制图块
			let newBlkRefId = mxcad.drawEntity(blkRef);
			if (!newBlkRefId.isValid) {
				console.log("insert error");
				return;
			}
		};
	 * ```
	*/
	insertBlock(sFileUrl: string, sBlkName: string, isWorkThread?: boolean, fetchAttributes?: number, isUpdataInsertBlock?: boolean, isUpdataSameNameBlock?: boolean): Promise<McObjectId>;
	/**
	 * 获取当前文件名
	 * @returns 当前文件名
	 */
	getCurrentFileName(): string;
	/**
	 * 设置当前文件名
	 * @param fileName 当前文件名
	 */
	setCurrentFileName(fileName: string): void;
	/**
	 * 获取当前源文件名
	 * @returns 当前源文件名
	 */
	getCurrentOriginaFileName(): string;
	/**
	 * 设置当前源文件名
	 * @param fileName 当前源文件名
	 */
	setCurrentOriginaFileName(fileName: string): void;
	/**
	 * 将文件保存到服务器并转换为网络路径下载
	 * @param sSaveProgramUrl 后端 POST请求接口, 接口具体实现: 先下载MxDraw云图开发包<https://www.mxdraw.com/download.html>并解压
	 * 找到MxDrawCloudServer\Bin\MxDrawServer\Windows\routes\mxcad\upload.js 可以找到对应的实现接口"/savedwg",
	 * "/mxcad/savedwg":保存dwg文件到服务器
	 * "/mxcad/savefile":保存mxweb文件到服务器
	 * "/mxcad/savepdf":保存pdf文件到服务器
	 * 如果没有找到则在该项目下寻找这个接口的定义, 必须符合该接口的定义才能作为参数
	 * @param call 保存文件的结果回调 这里接收到的参数请自己根据接口定义中保存图纸的位置, ref.file 不是完整请求路径，只是保存后的图纸名称
	 * @returns 是否成功保存文件
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 * //保存dwg文件
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD()
	 *  MxCpp.getCurrentMxCAD().saveFileToUrl("http://localhost:1337/mxcad/savedwg", (iResult, sserverResult) => {
	 *    let ret = JSON.parse(sserverResult);
	 *    if (ret.ret == "ok") {
	 *        console.log(ret.file)
	 *        let saveFileUrl = "http://localhost:1337/mxcad/file/" + ret.file;
	 *        MxTools.downloadFileFromUrl(saveFileUrl, ret.file);
	 *    }
	 * })
	 * //保存pdf文件。
	 * import { MxCpp, McObject, MxTools } from "mxcad"
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD()
	 *  MxCpp.getCurrentMxCAD().saveFileToUrl("http://localhost:1337/mxcad/savepdf", (iResult, sserverResult) => {
	 *    let ret = JSON.parse(sserverResult);
	 *    if (ret.ret == "ok") {
	 *        console.log(ret.file)
	 *        let saveFileUrl = "http://localhost:1337/mxcad/file/" + ret.file;
	 *        MxTools.downloadFileFromUrl(saveFileUrl, ret.file);
	 *    }
	 * },"",JSON.stringify({ width: "2000", height: "2000" }));
	 * ```
	 */
	saveFileToUrl(sSaveProgramUrl: string, call: (iResult: number, sServerResult: string) => void, filename?: string, param?: any): boolean;
	/**
	 * 保存文件
	 * @param filename 另存为的新文件名称（另存为的文件均为 mxweb 格式）
	 * @param call 回调函数，可选参数，文件保存完成后的回调函数，参数为文件数据
	 * @param isDownland 是否下载文件，默认为 true
	 * @param isShowSaveFileDialog 是否显示保存文件对话框，默认为 true
	 * @returns 是否成功保存文件
	 * @example
	 * ```ts
	 * import { MxCpp, McObject, MxTools } from "mxcad"
	 * const mxcad:McObject = MxCpp.App.getCurrentMxCAD()
	 * const fileName =  mxcad.getCurrentFileName()
	 * mxcad.saveFile(fileName, (data)=> {
	 *   const blob = new Blob([data.buffer], { type: "application/octet-stream" });
	 * }, false, false)
	 * ```
	 */
	saveFile(filename?: string, call?: (data: any) => void, isDownland?: boolean, isShowSaveFileDialog?: boolean, parameter?: object): boolean;
	/**
	 * 获取数据库对象
	 * @returns 数据库对象
	 */
	getDatabase(): McDbDatabase;
	/**
	* 返回数据库对象
	*/
	get database(): McDbDatabase;
	/**
	 * 设置浏览模式
	 * param browse 是否浏览模式，true为浏览模式，false为编辑模式
	 */
	setBrowse(browse: boolean): void;
	/**
	 * 获取系统变量的字符串值
	 * @param varName 变量名称
	 * @returns 变量的字符串值
	 */
	getSysVarString(varName: string): string;
	/**
	 * 设置系统变量的字符串值
	 * @param varName 变量名称
	 * @param val 变量的字符串值
	 * @returns 是否成功设置变量值
	 */
	setSysVarString(varName: string, val: string): any;
	/**
	 * 获取系统变量的浮点数值
	 * @param varName 变量名称
	 * @returns 变量的浮点数值
	 */
	getSysVarDouble(varName: string): number;
	/**
	 * 进入块编辑状态
	 * @param idBlockRecord 块记录的ID
	 * @returns 是否成功进入块编辑状态
	 * @example
	 * ```ts
	 * import { MxCpp, McDbBlockReference, MxCADUtility, MxCADResbuf, DxfCode } from "mxcad";
	   async function Mx_StartBlockEdit() {
		let retIds = await MxCADUtility.selectEnt("选择需要被编辑的块引用", new MxCADResbuf([DxfCode.kEntityType, "INSERT"]));
		if (retIds.length == 0) {
			return;
		}
		let id = retIds[0];
		let ent = id.getMcDbEntity();
		if(ent instanceof McDbBlockReference){
			MxCpp.mxcad.startBlockEdit((ent as McDbBlockReference).blockTableRecordId);
		}
	   }
	 * ```
	 */
	startBlockEdit(idBlockRecord: McObjectId): boolean;
	/**
	 * 退出块编辑状态
	 */
	endBlockEdit(): boolean;
	/**
	 * 当前是否正在块编辑
	 */
	isBlockEditing(): boolean;
	/**
	 * 开始进入视口编辑状态
	 * @param idBlockRecord 视口记录对象id
	 * @example
	 * ```ts
	 * import { MxCpp, McDbViewport, MxCADUtility, MxCADResbuf, DxfCode } from "mxcad";
	 *
	  async function Mx_StartViewPortEdit() {
		let retIds = await MxCADUtility.selectEnt("选择需要编辑的视口", new MxCADResbuf([DxfCode.kEntityType, "VIEWPORT"]));
		if (retIds.length == 0) {
			return;
		}
		let id = retIds[0];
		
		let ent = id.getMcDbEntity();
		if(ent instanceof McDbViewport){
			MxCpp.mxcad.startViewPortEdit(id);
		}
	   }
	 * ```
	 */
	startViewPortEdit(idBlockRecord: McObjectId): boolean;
	/**
	 * 退出视口编辑状态
	 */
	endViewPortEdit(): boolean;
	/**
	 * 当前是否正视口编辑
	 */
	isViewPortEditing(): boolean;
	/**
	 * 获取系统变量的点数值
	 * @param varName 变量名称
	 * @returns 变量的点数值
	 */
	getSysVarPoint(varName: string): McGePoint3d;
	/**
   * 设置系统变量的点数值
   * @param varName 变量名称
   * @param val 变量的点数值
   * @returns 是否成功设置变量值
   */
	setSysVarPoint(varName: string, pt: McGePoint3d): boolean;
	/**
	* 设置系统变量的2维点数值
	* @param varName 变量名称
	* @param val 变量的点数值
	* @returns 是否成功设置变量值
	*/
	setSysVarPoint2d(varName: string, pt: McGePoint3d): boolean;
	/**
	 * 设置系统变量的浮点数值
	 * @param varName 变量名称
	 * @param val 变量的浮点数值
	 * @returns 是否成功设置变量值
	 */
	setSysVarDouble(varName: string, val: number): boolean;
	/**
	 * 获取系统变量的整数值
	 * @param varName 变量名称
	 * @returns 变量的整数值
	 */
	getSysVarLong(varName: string): number;
	/**
	 * 设置系统变量的整数值
	 * @param varName 变量名称
	 * @param val 变量的整数值
	 * @returns 是否成功设置变量值
	 */
	setSysVarLong(varName: string, val: number): boolean;
	/**
	 * 获取绘制颜色
	 * @returns 返回绘制颜色
	 */
	get drawColor(): McCmColor;
	/**
	 * 设置绘制颜色
	 * @param val 绘制颜色
	 */
	set drawColor(val: McCmColor);
	/**
	 * 设置绘制颜色索引
	 * @returns val 颜色索引类型
	 */
	get drawColorIndex(): number;
	/**
	 * 设置绘制颜色索引
	 * @param val 颜色索引类型
	 * @example
	 * ```ts
	 * import { MxCpp, ColorIndexType, McObject } from "mxcad" ;
	 * const mxcad:McObject = MxCpp.App.getCurrentMxCAD();
	 * mxcad.drawColorIndex = ColorIndexType.kMagenta;
	 * ```
	 */
	set drawColorIndex(val: ColorIndexType | number);
	/**
	 * 获取绘制线宽
	 * @returns 返回绘制线宽
	 */
	get drawLineWeight(): McDb.LineWeight;
	/**
	 * 设置绘制线宽
	 * @param val 绘制线宽
	 * @example
	 * ```ts
	 * import { MxCpp, McDb, McObject } from "mxcad" ;
	 *
	 * const mxcad: McObject = MxCpp.getCurrentMxCAD();
	 * mxcad.drawLineWeight(McDb.LineWeight.kLnWtByLayer)
	 * ```
	 */
	set drawLineWeight(val: McDb.LineWeight);
	/**
	 * 获取绘制线型比例
	 * @returns 返回绘制线型比例
	 */
	get drawLineTypeScale(): number;
	/**
	 * 设置绘制线型比例
	 * @param val 绘制线型比例
	 */
	set drawLineTypeScale(val: number);
	/**
	 * 获取绘制线型
	 * @returns 返回绘制线型
	 */
	get drawLinetype(): string;
	/**
	 * 设置绘制线型
	 * @param val 绘制线型名
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad" ;
	 *
	 * const mxcad: McObject = MxCpp.getCurrentMxCAD();
	 * mxcad.addLinetype("MyLineType3", "30,-10");
	 * mxcad.drawLinetype = "MyLineType3";
	 * ```
	 */
	set drawLinetype(val: string);
	/**
	 * 获取绘制文字样式
	 * @returns 返回绘制文字样式名
	 */
	get drawTextStyle(): string;
	/**
	 * 设置绘制文字样式
	 * @param val 绘制文字样式名
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad" ;
	 *
	 * const mxcad: McObject = MxCpp.getCurrentMxCAD();
	 * mxcad.addTextStyle("MyTextStyle", "italicc.shx", "gbcbig.shx", 0.7);
	 * mxcad.drawTextStyle = "MyTextStyle";
	 * ```
	 */
	set drawTextStyle(val: string);
	/**
	 * 获取绘制图层
	 * @returns 返回绘制图层
	 */
	get drawLayer(): string;
	/**
	 * 设置绘制图层
	 * @param val 绘制图层
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from 'mxcad'
	   const mxcad:McObject = MxCpp.getCurrentMxCAD();
		mxcad.drawLayer = "MtextLayer";
	 * ```
	 */
	set drawLayer(val: string);
	/**
	 * 添加图层
	 * @param pszName 图层名称
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD()
	 * mxcad.addLayer("图层名称")
	 * ```
	 */
	addLayer(string: string): McObjectId;
	/**
	 * 添加文字样式
	 * @param pszName 样式名称
	 * @param pszFileName 字体文件名
	 * @param pszBigFontFileName 大字体文件名
	 * @param dXScale X 方向缩放比例
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 *  const mxcad:McObject = MxCpp.getCurrentMxCAD()
		//按指定样式绘制文字
		mxcad.addTextStyle("MyTextStyle", "italicc.shx", "gbcbig.shx", 0.7);
		mxcad.drawTextStyle = "MyTextStyle";
		mxcad.drawColor = new McCmColor(255, 0, 0);
		mxcad.drawText(0, 3000, "绘图控件文字测试", 100, 0, 0, 1);
	 * ```
	 */
	addTextStyle(sName: string, sFileName: string, sBigFontFileName: string, dXScale?: number): McObjectId;
	/**
	 * 添加使用TrueType字体的文字样式
	 * @param pszName 样式名称
	 * @param sTrueTypeFontName TrueType字体名,为空使用默认TrueType字体.
	 * @param dXScale X 方向缩放比例
	 * @example
	 * ```ts
	 * // 在MxCAD中使用TrueType字体的文字样式
	 * import { MxCpp } from "mxcad"
	 *
		function Mx_Test_TrueText() {
			let mat: McGeMatrix3d = new McGeMatrix3d();
			let mxcad = MxCpp.getCurrentMxCAD();
			//清空当前显示内容
			mxcad.newFile();
			MxCpp.App.loadFonts([], [], ["syadobe", "simsun", "sysimsun"], () => {
				mxcad.AddTureTypeTextStyle("ht_style", "syadobe");
				mxcad.AddTureTypeTextStyle("st_style", "simsun");
				mxcad.drawTextStyle = "ht_style";

				mxcad.drawColor = new McCmColor(200, 255, 50);
				let idText = mxcad.drawText(0, 3500, "绘图控件TrueType文字测试", 100, 0, 0, 1);

				let ent = idText.getMcDbEntity();
				if (ent) ent.textStyle = "st_style";

				let txt: McDbText = ent as McDbText;
				txt.adjustAlignment();
				mxcad.zoomAll();
				mxcad.regen();
				mxcad.updateDisplay();
			});
		}
	 * ```
	 */
	AddTureTypeTextStyle(sName: string, sTrueTypeFontName?: string, dXScale?: number): McObjectId;
	/**
	 * 添加线型
	 * @param pszName 线型名称
	 * @param pszLineDefine 线型定义
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 *  const mxcad:McObject = MxCpp.getCurrentMxCAD()
		//定义虚线数据据,"MyLineType"是线型名，"6,-8"是虚线的一个单位定义，6是实线长，-8是空格长。
		mxcad.addLinetype("MyLineType", "6,-8");
		//设计当前线型为"MyLineType"
		mxcad.drawLinetype = "MyLineType";
		// 绘制一个虚线
		mxcad.drawLine(0, 30, 100, 30);
		// 绘制一个斜虚线
		mxcad.drawLine(200, 30, 300, 130);
	 * ```
	 */
	addLinetype(sName: string, sLineDefine: string): McObjectId;
	/**
	 * 添加线型
	 * @param pszName 线型名称
	 * @param pszLineDefine 线型定义
	 * @param pszTextStyle 文字样式
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 *  const mxcad:McObject = MxCpp.getCurrentMxCAD()
		//增加一个带有字体样式的线型
		mxcad.addTextStyle("MyLineTypeTextStyle", "txt.shx", "hztxt.shx", 1);
		mxcad.addLinetypeEx("MyLineType3", "(12.7,(\"T=MxDraw\",\"S=2.54\",\"L=-5.08\",\"R=0.0\",\"X=-2.54\",\"Y=-1.27\"),-10.08)", "MyLineTypeTextStyle");
		mxcad.drawLinetype = "MyLineType3";
		mxcad.drawLineWidth = 0;
		//绘制一个带宽度的红色点划线。
		mxcad.drawLine(350, 120, 600, 120);
	 * ```
	 */
	addLinetypeEx(sName: string, sLineDefine: string, sTextStyle?: string): McObjectId;
	/**
	 * 创建布局
	 * @param pszName 布局名称
	 */
	createLayout(sName: string): McObjectId;
	/**
	 * 删除布局
	 * @param pszName 布局名称
	 */
	deleteLayout(sName: string): boolean;
	/**
	 * 布局改名
	 * @param sName 布局名称
	 * @param sToName 新布局名称
	 */
	layoutRename(sName: string, sToName: string): boolean;
	/**
	 * 绘制二维直线
	 * @param dX1 起点 X 坐标
	 * @param dY1 起点 Y 坐标
	 * @param dX2 终点 X 坐标
	 * @param dY2 终点 Y 坐标
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD()
	 * mxcad.drawLine(0, 60, 100, 60);
	 * ```
	 */
	drawLine(dX1: number, dY1: number, dX2: number, dY2: number): McObjectId;
	/**
	 * 绘制三维直线
	 * @param dX1 起点 X 坐标
	 * @param dY1 起点 Y 坐标
	 * @param dZ1 起点 Z 坐标
	 * @param dX2 终点 X 坐标
	 * @param dY2 终点 Y 坐标
	 * @param dZ2 终点 Z 坐标
	 * @returns
	 */
	drawLine3d(dX1: number, dY1: number, dZ1: number, dX2: number, dY2: number, dZ2: number): McObjectId;
	/**
	 * 添加标注样式
	 * @param pszName 样式名称
	 * @param pszDoubleData 双精度型数据
	 * @param pszIntData 整型数据
	 * @param pszStringData 字符串型数据
	 * @param pszIdData ID 型数据
	 *
	 * @description pszDoubleData 双精度型数据
	 * | 系统变量 | 值 | 功能说明 |
	 * | ------- | ------- | ------- |
	 * | dimaltf | 143 | 控制换算单位的乘数 |
	 * | dimasz | 41  | 控制尺寸线和引线箭头的大小。并控制基线的大小。|
	 * | dimcen | 141 | 控制圆或圆弧圆心标记以及中心线的绘制。|
	 * | dimdle |  46  | 当使用小斜线代替箭头进行标注时，设置尺寸线超出尺寸界线的距离。|
	 * | dimdli |  43 | 控制基线标注中尺寸线的间距。|
	 * | dimexe |  44 | 将命名标注样式及其设置输出到外部文件。|
	 * | dimexo |  42 | 指定尺寸界线偏离原点的距离。|
	 * | dimgap |  147 | 设置当打断尺寸线以符合标注文字时，标注文字周围的距离。|
	 * | dimlfac | 144 | 为线性标注测量值设置比例因子。|
	 * | dimrnd |  45 | 将所有标注距离舍入为指定值。|
	 * | dimscale | 40 | 设置应用于标注变量（用于指定尺寸、距离或偏移量）的全局比例因子。|
	 * | dimtfac | 146 | 与通过 DIMTXT 系统变量设置一样，指定分数和公差值的文字高度相对于标注文字高度的比例因子。|
	 * | dimtm  |  48 | 为标注文字设置最小（即最低）公差限制。|
	 * | dimtp  |  47 | 为标注文字设置最大（即最高）公差限制。|
	 * | dimtsz |  142 | DIMTSZ = 0使用标准的实心箭头，DIMTSZ > 0 标注的箭头被替换为倾斜线（建筑标记），而 DIMTSZ 的数值就是这条倾斜线的长度|
	 * | dimtvp |  145 | 控制标注文字在尺寸线上方或下方的垂直位置。|
	 * | dimtxt |  140 | 指定标注文字的高度（除非当前文字样式具有固定的高度）。|
	 * | dimaltrnd | 148 | 舍入换算标注单位。|
	 *
	 * @description pszIntData 整型数据
	 * | 系统变量 | 值 | 功能说明 |
	 * | ------- | ------- | ------- |
	 * | dimadec | 179 | 控制角度标注中显示的精度小数位数。|
	 * | dimalt | 170 | 控制标注中换算单位的显示。|
	 * | dimaltd | 171 | 控制换算单位中的小数位数。|
	 * | dimalttd | 274 | 设置换算标注单位中的公差值的小数位数。|
	 * | dimalttz | 286 | 控制对公差值的消零处理。|
	 * | dimaltu | 273 | 为所有标注子样式（角度标注除外）的换算单位设定单位格式。|
	 * | dimaltz | 285 | 控制对换算单位标注值的消零处理。|
	 * | dimaunit | 275 | 为角度标注设定单位格式。|
	 * | dimclrd | 176 | 为尺寸线、箭头和标注引线指定颜色。|
	 * | dimclre | 177 | 为尺寸界线、圆心标记和中心线指定颜色。|
	 * | dimclrt | 178 | 为标注文字指定颜色。|
	 * | dimdec | 271 | 设置标注主单位中显示的小数位数。|
	 * | dimfit | 287 | 尺寸界线内的空间不足以同时放下标注文字和箭头时，此系统变量将确定这两者的排列方式。|
	 * | dimjust | 280 | 控制标注文字的水平位置。|
	 * | dimlim | 72 | 生成标注界限作为默认文字。|
	 * | dimsah | 173 | 控制尺寸线箭头块的显示。|
	 * | dimsd1 | 281 | 控制是否隐去第一条尺寸线和箭头。|
	 * | dimsd2 | 282 | 控制是否隐去第二条尺寸线和箭头。|
	 * | dimse1 | 75 | 控制是否隐去第一条尺寸界线。|
	 * | dimse2 | 76 | 控制是否隐去第二条尺寸界线。|
	 * | dimsoxd | 175 | 如果尺寸界线内没有足够的空间，则隐去箭头。|
	 * | dimtad | 77 | 控制文字相对于尺寸线的垂直位置。|
	 * | dimtdec | 272 | 设置标注主单位的公差值中显示的小数位数。|
	 * | dimtih | 73 | 控制所有标注类型（坐标标注除外）的标注文字在尺寸界线内的位置。 |
	 * | dimtix | 174 | 在尺寸界线之间绘制文字。|
	 * | dimtofl | 172 | 控制是否在尺寸界线之间绘制尺寸线（即使标注文字被放置在尺寸界线之外）。|
	 * | dimtoh | 74 | 控制标注文字在尺寸界线外的位置。|
	 * | dimtol | 71 | 将公差附在标注文字中。|
	 * | dimtolj | 283 | 设置公差值相对于表面标注文字的垂直对正方式。|
	 * | dimzin  | 78 | 控制针对主单位值的消零处理。|
	 * | dimupt | 288 | 控制用户定位文字的选项。|
	 * | dimtzin | 284 | 控制对公差值的消零处理。|
	 * | dimfrac | 276 | 设置分数格式。|
	 * | dimlunit | 277 | 为所有标注类型（角度标注除外）设置单位。|
	 * | dimatfit | 289 | 尺寸界线内的空间不足以同时放下标注文字和箭头时，此系统变量将确定这两者的排列方式。|
	 * | dimtmove | 279 | 设置标注文字的移动规则。|
	 * | dimazin | 79 | 针对角度标注进行消零处理。|
	 *
	 * @description pszStringData 字符串型数据
	 * | 系统变量 | 值 | 功能说明 |
	 * | ------- | ------- | ------- |
	 * | dimapost | 4 | 指定用于所有标注类型（角度标注除外）的换算标注测量值的文字前缀或后缀（或两者都指定）。|
	 * | dimpost | 3 | 为标注测量值指定文字前缀或后缀（或两者）。|
	 *
	 * @description pszIdData ID 型数据
	 * | 系统变量 | 值 | 功能说明 |
	 * | ------- | ------- | ------- |
	 * | dimblk | 342 | 为尺寸线的第二个端点设置箭头 。|
	 * | dimblk1 | 343 | 为尺寸线的第一个端点设置箭头。|
	 * | dimblk2 | 344 | 为尺寸线的第二个端点设置箭头。|
	 * | dimldrblk | 341 | 指定引线箭头的类型。|
	 * | dimtxsty | 340 | 指定标注的文字样式。|
	 *
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 *  const mxcad:McObject = MxCpp.getCurrentMxCAD();
		//清空当前显示内容
		mxcad.newFile();
		// 创建一个新的文字样式
		let textId = mxcad.addTextStyle("我的标注字体", "txt.shx", "gbcbig.shx", 1);
		// 创建一个新的标注样式
		mxcad.addDimStyle("MyDimStyle", "41,0.18,141,0.09,40,200", "77,1,271,3", '3,"%%c<>"', `340,${textId.id}`);
		mxcad.drawDimStyle = "MyDimStyle"

		mxcad.drawDimAligned(0, 4000, 300, 4500, 150, 4600);
		//把所有的实体都放到当前显示视区
		mxcad.zoomAll();
		//更新视区显示
		mxcad.updateDisplay();
	 * ```
	 */
	addDimStyle(pszName: string, pszDoubleData: string, pszIntData: string, pszStringData: string, pszIdData: string): McObjectId;
	/**
	 * 获取当前绘制的标注样式
	 */
	get drawDimStyle(): string;
	/**
	 * 设置当前绘制的标注样式
	 * @param val 样式名称
	 */
	set drawDimStyle(val: string);
	/**
	 * 把当前路径做上排除标记，主要用于填充的绘制，把这个路径组成的闭合区域在填充中挖去
	 * @param isExclude 是否排除
	 * @example
	 * ```ts
	 * //绘制一个实心有圆弧边界填充,中间挖去一块.
	 *
		import { MxCpp, McObject } from "mxcad";

		const mxcad:McObject = MxCpp.getCurrentMxCAD()
		
		//定义一个路径的开始点
		mxcad.pathMoveToEx(440, 3310, 0, 0, 0);
		//路径的一下个点
		mxcad.pathLineTo(480, 3310);
		//路径的一下个点
		mxcad.pathLineTo(480, 3360);
		//路径的一下个点
		mxcad.pathLineTo(450, 3340);
		// 把上面定义的路径定义填充排除区域.
		mxcad.pathMakeExclude(true);
		//定义一个路径的开始点
		mxcad.pathMoveToEx(400, 3300, 0, 0, 0.3);
		//路径的一下个点
		mxcad.pathLineTo(500, 3300);
		//路径的一下个点
		mxcad.pathLineTo(500, 3400);
		//路径的一下个点
		mxcad.pathLineTo(400, 3300);
		mxcad.drawColor = new McCmColor(255, 25, 0);
		//把路径变成一个填充
		mxcad.drawPathToHatch(1);
	 * ```
	 */
	pathMakeExclude(isExclude: boolean): void;
	/**
	 * 增加一个图案定义
	 * @param sName 图案名称
	 * @param sDefinitionData 图案默认定义数据
	 * @example
	 * ```ts
		import { MxCpp, McObject } from "mxcad"
		const mxcad:McObject = MxCpp.getCurrentMxCAD()
		//angle, x-origin,y-origin, delta-x,delta-y,dash-1,dash-2, …
		//45 = angle 是图案线角度.
		//0 = x-origin 是第一个填充线经过的点位置X坐标
		//0 = y-origin 是第一个填充线经过的点位置Y坐标
		//0 = delta-x   是下一个填充线相对前一个线的X方向偏移
		//0.125 = delta-y   是下一个填充线相对前一个线的Y方向偏移
		mxcad.addPatternDefinition("MyHatchPattern1", "((45, 0,0, 0,0.125))");
		mxcad.drawPatternDefinition = "MyHatchPattern1";
		//定义一个路径的开始点
		mxcad.pathMoveToEx(600, 3300, 0, 0, 0.3);
		//路径的一下个点
		mxcad.pathLineTo(700, 3300);
		//路径的一下个点
		mxcad.pathLineTo(700, 3400);
		//路径的一下个点
		mxcad.pathLineTo(600, 3300);
		//把路径变成一个填充,80,是填充图案的缩放比例.
		mxcad.drawPathToHatch(80);
	 * ```
	 */
	addPatternDefinition(sName: string, sDefinitionData: string): void;
	/**
	 * 获取当前绘制的线型定义
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 *  const mxcad: McObject = MxCpp.getCurrentMxCAD()
		//绘制另一个有图案的填充
		//45, 0,0, 0,.25
		//45, .176776695,0, 0,.25, .125,-.0625
		mxcad.addPatternDefinition("MyHatchPattern2", "((45, 0,0, 0,0.25) (45, 0.176776695,0, 0,0.25, 0.125,-0.0625))");
		mxcad.drawPatternDefinition = "MyHatchPattern2"
		//定义一个路径的开始点
		mxcad.pathMoveToEx(800, 3300, 0, 0, 0.3);
		//路径的一下个点
		mxcad.pathLineTo(900, 3300);
		//路径的一下个点
		mxcad.pathLineTo(900, 3400);
		//路径的一下个点
		mxcad.pathLineTo(800, 3300);
		//把路径变成一个填充,80,是填充图案的缩放比例.
		mxcad.drawPathToHatch(80);
	 * ```
	 */
	get drawPatternDefinition(): string;
	/**
	 * 设置当前绘制的线型定义
	 * @param val 线型定义
	 */
	set drawPatternDefinition(val: string);
	/**
	 * 获取当前绘制的线宽
	 */
	get drawLineWidth(): number;
	/**
	 * 设置当前绘制的线宽
	 * @param val 线宽
	 */
	set drawLineWidth(val: number);
	/**
	 * 返回调用draw开头的绘图数，使用数据库的当前默认属性。
	 */
	get drawUseDefaultProperties(): boolean;
	/**
	 * 设置调用draw开头的绘图数，使用数据库的当前默认属性
	 * @param val 线宽
	 */
	set drawUseDefaultProperties(val: boolean);
	/**
	 * 绘制圆弧
	 * @param dCenterX 圆心 X 坐标
	 * @param dCenterY 圆心 Y 坐标
	 * @param dRadius 半径
	 * @param dStartAng 起始角度，单位为弧度
	 * @param dEndAng 结束角度，单位为弧度
	 * @returns 成功返回 1，失败返回 0
	 */
	drawArc(dCenterX: number, dCenterY: number, dRadius: number, dStartAng: number, dEndAng: number): McObjectId;
	/**
	 * 绘制圆弧
	 * @param dStartPointX 起始点 X 坐标
	 * @param dStartPointY 起始点 Y 坐标
	 * @param dMidPointX 中间点 X 坐标
	 * @param dMidPointY 中间点 Y 坐标
	 * @param dEndPointX 结束点 X 坐标
	 * @param dEndPointY 结束点 Y 坐标
	 */
	drawArc2(dStartPointX: number, dStartPointY: number, dMidPointX: number, dMidPointY: number, dEndPointX: number, dEndPointY: number): McObjectId;
	/**
	* 绘制圆弧
	* @param dStartPointX 起始点 X 坐标
	* @param dStartPointY 起始点 Y 坐标
	* @param dEndPointX 结束点 X 坐标
	* @param dEndPointY 结束点 Y 坐标
	* @param dBulge 凸度
	*/
	drawArc3(dStartPointX: number, dStartPointY: number, dEndPointX: number, dEndPointY: number, dBulge: number): McObjectId;
	/**
	 * 绘制圆
	 * @param dCenterX 圆心 X 坐标
	 * @param dCenterY 圆心 Y 坐标
	 * @param dRadius 半径
	 */
	drawCircle(dCenterX: number, dCenterY: number, dRadius: number): McObjectId;
	/**
	 * 加载一个外部图片到当前上下文，方便后面使用。
	 * @param imageUrl 图片路径
	 * @param call 回调函数
	 * @example
	 * ```ts
	 * import { MxCpp, MxCADUiPrPoint } from "mxcad"
	 *
		async function Mx_Test_DrawImage() {
			const getPoint = new MxCADUiPrPoint();
			getPoint.setMessage("\n指定插入点:");
			let pt = await getPoint.go();
			if (!pt) return;
			let mxcad = MxCpp.getCurrentMxCAD();
			let imagUrl = "https://cdn.pixabay.com/photo/2022/11/15/12/23/winter-7593872_960_720.jpg";
			mxcad.loadImage(imagUrl, (image) => {
				if (!image) {
					console.log("loadImage failed");
					return;
				}
				let width = mxcad.mxdraw.viewCoordLong2Cad(100);
				let height = (image.height / image.width) * width;
				//let viewAngle = mxcad.mxdraw.getViewAngle() * 180  / Math.PI;
				//let viewAngle = mxcad.database.ucsMatrix.angleXYPlane() * 180  / Math.PI;
				//let viewAngle = 15.0;
				let viewAngle = 0.0;
				let id = mxcad.drawImage((pt as any).x, (pt as any).y, width, height, viewAngle, imagUrl, true, image.width, image.height);
				let ent = id.getMcDbEntity();
				if (ent) {
					ent.trueColor = new McCmColor(255, 255, 255, 160);
					// ent.rotate(pt,45 * 3.14159265 / 180.0);
				}
				mxcad.updateDisplay();
			});
		}
	 * ```
	 */
	loadImage(imageUrl: string, call: (image: any) => void, imageFileName?: string, fileType?: string): void;
	/**
	* 加载Base64图片。
	* @param imageUrl 图片路径
	* @param call 回调函数
	* @example
	* ```ts
		import { MxCpp } from "mxcad";
		function selectLocalFile() {
			return new Promise((resolve) => {
				const input = document.createElement("input");
				input.type = "file";
				input.accept = "image/*";
				input.onchange = (e) => resolve(e.target.files[0]);
				input.click();
			});
		}
		function fileToBase64(file) {
			return new Promise((resolve, reject) => {
				const reader = new FileReader();
				reader.onload = () => resolve(reader.result);
				reader.onerror = reject;
				reader.readAsDataURL(file);
			});
		}

		const file = await selectLocalFile();
		if (!file) return;
		const imagData = await fileToBase64(file);
		let mxcad = MxCpp.getCurrentMxCAD();

		mxcad.loadImageBase64(imagData, "test.jpg", (image) => {
			if (!image) {
				console.log("loadImage failed");
				return;
			}
			let width = mxcad.mxdraw.viewCoordLong2Cad(100);
			let height = (image.height / image.width) * width;

			let viewAngle = 0.0;
			let id = mxcad.drawImage(100, 100, width, height, viewAngle, "test.jpg", true, image.width, image.height,"",imagData);
			mxcad.updateDisplay();
		})
	* ```
	*/
	loadImageBase64(sImageBase64: string, imageFileName: string, call: (image: any) => void): void;
	/**
	 * 绘制一个图片
	 * @param dPosX 图片 X 坐标
	 * @param dPosY 图片 Y 坐标
	 * @param dWidth 图片宽度
	 * @param dHeight 图片高度
	 * @param dAng 图片角度,单位是度
	 * @param imageUrl 图片路径
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 *
		async function Mx_Test_DrawImageBase64() {
			const getPoint = new MxCADUiPrPoint();
			getPoint.setMessage("\n指定插入点:");
			let pt = await getPoint.go();
			if (!pt) return;

			let mxcad = MxCpp.getCurrentMxCAD();
			let imagData = "data:image/jpeg;base64,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";
			mxcad.loadImageBase64(imagData, "test.jpg", (image) => {
				if (!image) {
					console.log("loadImage failed");
					return;
				}
				let width = mxcad.mxdraw.viewCoordLong2Cad(100);
				let height = (image.height / image.width) * width;

				let viewAngle = 0.0;
				let id = mxcad.drawImage((pt as any).x, (pt as any).y, width, height, viewAngle, "test.jpg", false, image.width, image.height);
				let ent = id.getMcDbEntity();
				if (ent) {
					ent.trueColor = new McCmColor(255, 255, 255, 160);
				}
				mxcad.updateDisplay();
			});
		}
	 * ```
	 */
	drawImage(dPosX: number, dPosY: number, dWidth: number, dHeight: number, dAng: number, imageName: string, isConvertBase64?: boolean, dwgImageSizeWidth?: number, dwgImageSizeHeight?: number, imageUrl?: string, sImageBase64?: string): McObjectId;
	/**
	 * 将图片定义添加到 CAD 数据库中，供后续插入图片对象时复用。
	 *
	 * 该方法通常和 loadImage / drawImage 配合使用，先把图片资源加载到内存，
	 * 再把图片定义注册到数据库中，最后通过 drawImage 将图片真实插入到图纸中。
	 *
	 * @param imageUrl 图片地址。
	 * @param sName 图片定义名称。
	 * @param isConvertBase64 是否将图片转换为 Base64 数据。
	 * @param sourceFileName 图片源文件名。
	 * @param sBase64Data Base64 数据内容。
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad";
	 *
	 * const mxcad: McObject = MxCpp.getCurrentMxCAD();
	 * const imagUrl = "https://cdn.pixabay.com/photo/2022/11/15/12/23/winter-7593872_960_720.jpg";
	 *
	 * mxcad.loadImage(imagUrl, (imagedata) => {
	 *   if (!imagedata) {
	 *     console.log("loadImage failed");
	 *     return;
	 *   }
	 *   mxcad.addImageDefine(imagUrl, "winter-7593872_960_720.jpg", true);
	 *   mxcad.updateDisplay();
	 * });
	 * ```
	 */
	addImageDefine(imageUrl: string, sName?: string, isConvertBase64?: boolean, sourceFileName?: string, sBase64Data?: string): McObjectId;
	/**
	 * 控制当前视口是否显示线宽效果。
	 *
	 * 适用于需要查看线宽显示效果、调试绘图样式或在图纸中观察线宽是否生效的场景。
	 * 开启后会立即刷新当前视图，便于观察绘制结果。
	 *
	 * @param isShow 是否显示线宽。
	 * @returns 执行结果。
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 *
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * let showLineWeight = false;
	 *
	 * function toggleLineWeight() {
	 *   showLineWeight = !showLineWeight;
	 *   mxcad.showLineWeight(showLineWeight);
	 * }
	 * ```
	 */
	showLineWeight(isShow: boolean): boolean;
	/**
	 * 将另一个 DWG 文件作为当前图纸的背景对象加载。
	 *
	 * 常用于底图对比、参考图叠加、背景图显示等场景。加载成功后，
	 * 该背景对象会以当前图纸的背景方式参与显示。
	 *
	 * @param sFileUrl 背景文件地址。
	 * @param call 加载完成后的回调，参数为布尔值，表示是否加载成功。
	 * @param color 背景对象显示颜色，默认为 0。
	 * @param isShow 是否显示背景对象。
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 *
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * mxcad.loadDwgBackground("./demo/background.dwg.mxweb", (ret) => {
	 *   console.log("背景加载结果：", ret);
	 * });
	 * ```
	 */
	loadDwgBackground(sFileUrl: string, call: (ret: boolean) => void, color?: number, isShow?: boolean): void;
	/**
	 * 返回当前已加载的背景对象。
	 *
	 * 该对象可用于进一步控制背景图的显示、清空或修改样式。
	 * @returns 当前背景对象实例。
	 */
	getBackgroundEntity(): McDbBackgroundEntity;
	/**
	 * 清空当前背景绘制对象。
	 *
	 * 适用于关闭背景显示、切换参考图或重新加载背景资源时使用。
	 */
	clearDwgBackground(): void;
	/**
	 * 注册需要监听的系统变量名。
	 *
	 * 当这些系统变量被修改时，会触发 sysVarChanged 事件，适用于联动控制、
	 * 状态同步或自定义交互逻辑。
	 *
	 * @param aryVarName 系统变量名称数组。
	 * @example
	 * ```ts
	 * const mxcad = MxCpp.getCurrentMxCAD();
	 * mxcad.addSystemVarNameForEvent(["GRIDMODE", "AUTOSNAP"]);
	 * ```
	 */
	addSystemVarNameForEvent(aryVarName: string[]): void;
	/**
	 * 绘制椭圆
	 * @param dCenterX 椭圆中心 X 坐标
	 * @param dCenterY 椭圆中心 Y 坐标
	 * @param dMajorAxisX 长轴 X 坐标
	 * @param dMajorAxisY 长轴 Y 坐标
	 * @param dRadiusRatio 短轴与长轴的比例
	 * @returns 成功返回 1，失败返回 0
	 */
	drawEllipse(dCenterX: number, dCenterY: number, dMajorAxisX: number, dMajorAxisY: number, dRadiusRatio: number): McObjectId;
	/**
	 * 绘制椭圆弧
	 * @param dCenterX 椭圆中心 X 坐标
	 * @param dCenterY 椭圆中心 Y 坐标
	 * @param dMajorAxisX 长轴 X 坐标
	 * @param dMajorAxisY 长轴 Y 坐标
	 * @param dRadiusRatio 短轴与长轴的比例
	 * @param dStartAng 起始角度，单位为弧度
	 * @param dEndAng 结束角度，单位为弧度
	 */
	drawEllipseArc(dCenterX: number, dCenterY: number, dMajorAxisX: number, dMajorAxisY: number, dRadiusRatio: number, dStartAng: number, dEndAng: number): McObjectId;
	/**
	 * 绘制点
	 * @param dX X 坐标
	 * @param dY Y 坐标
	 */
	drawPoint(dX: number, dY: number): McObjectId;
	/**
	 * 绘制实体
	 * @param dX1 第一个点 X 坐标
	 * @param dY1 第一个点 Y 坐标
	 * @param dX2 第二个点 X 坐标
	 * @param dY2 第二个点 Y 坐标
	 * @param dX3 第三个点 X 坐标
	 * @param dY3 第三个点 Y 坐标
	 * @param dX4 第四个点 X 坐标
	 * @param dY4 第四个点 Y 坐标
	 * @returns 实体对象id
	 */
	drawSolid(dX1: number, dY1: number, dX2: number, dY2: number, dX3: number, dY3: number, dX4: number, dY4: number): McObjectId;
	/**
	 * 绘制多行文本
	 * @param dPosX 文本位置 X 坐标
	 * @param dPosY 文本位置 Y 坐标
	 * @param pszContents 文本内容
	 * @param dHeight 文本高度
	 * @param dWidth 文本宽度
	 * @param dRotation 旋转角度，单位为弧度
	 * @param iAttachment 对齐方式
	 * @returns 多行文本对象id
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD()
	 * mxcad.drawMText(0, -100, "控件:\\P多行文字测试", 50, 400, 0, 1);
	 * ```
	 * ```ts   绘下标，下标方法
	 *  let mxcad = MxCpp.getCurrentMxCAD();
	 *  mxcad.newFile();
	 *  mxcad.drawMText(0,0,"\\A1;平方方法下标: m{\\H0.7x;\\S^2;}",15,500,0.0,7);
	 *  mxcad.drawMText(0,30,"\\A2;平方方法上标: m{\\H0.3x;\\S 2^;}",15,500,0.0,7);
	 *  mxcad.zoomAll();
	 *  mxcad.updateDisplay();
	 * ```
	 */
	drawMText(dPosX: number, dPosY: number, sContents: string, dHeight: number, dWidth: number, dRotation: number, iAttachment: McDb.AttachmentPoint): McObjectId;
	/**
	 * 绘制单行文本
	 * @param dPosX 文本位置 X 坐标
	 * @param dPosY 文本位置 Y 坐标
	 * @param pszText 文本内容
	 * @param dHeight 文本高度
	 * @param dRotation 旋转角度，单位为弧度
	 * @param horizontalMode 横向对齐方式
	 * @param verticalMode 纵向对齐方式
	 * @returns 成功返回 1，失败返回 0
	 * @example
	 * ```ts
	 * import { MxCpp, McObject } from "mxcad"
	 * const mxcad:McObject = MxCpp.getCurrentMxCAD()
	 * mxcad.drawText(0, 1900, "绘图控件文字测试", 100, 0, 0, 1);
	 * ```
	 */
	drawText(dPosX: number, dPosY: number, pszText: string, dHeight: number, dRotation: number, horizontalMode: McDb.TextHorzMode, verticalMode: McDb.TextVertMode): McObjectId;
	/**
	 * 绘制块参照
	 * @param dPosX 参照位置 X 坐标
	 * @param dPosY 参照位置 Y 坐标
	 * @param pszBlkName 块名
	 * @param dScale 缩放比例
	 * @param dAng 旋转角度，单位为弧度
	 * @returns 块对象id
	 */
	drawBlockReference(dPosX: number, dPosY: number, sBlkName: string, dScale: number, dAng: number): McObjectId;
	/**
	 * 绘制对齐标注
	 * @param dExtLine1PointX 第一条尺线起点 X 坐标
	 * @param dExtLine1PointY 第一条尺线起点 Y 坐标
	 * @param dExtLine2PointX 第二条尺线起点 X 坐标
	 * @param dExtLine2PointY 第二条尺线起点 Y 坐标
	 * @param dTextPositionX 文本位置 X 坐标
	 * @param dTextPositionY 文本位置 Y 坐标
	 * @returns 成功返回 1，失败返回 0
	 */
	drawDimAligned(dExtLine1PointX: number, dExtLine1PointY: number, dExtLine2PointX: number, dExtLine2PointY: number, dTextPositionX: number, dTextPositionY: number): McObjectId;
	/**
	 * 绘制角度标注
	 * @param dAngleVertexX 角度顶点 X 坐标
	 * @param dAngleVertexY 角度顶点 Y 坐标
	 * @param dFirstEndPointX 第一条尺线起点 X 坐标
	 * @param dFirstEndPointY 第一条尺线起点 Y 坐标
	 * @param dSecondEndPointX 第二条尺线起点 X 坐标
	 * @param dSecondEndPointY 第二条尺线起点 Y 坐标
	 * @param dTextPointX 文本位置 X 坐标
	 * @param dTextPointY 文本位置 Y 坐标
	 * @returns 成功返回 1，失败返回 0
	 */
	drawDimAngular(dAngleVertexX: number, dAngleVertexY: number, dFirstEndPointX: number, dFirstEndPointY: number, dSecondEndPointX: number, dSecondEndPointY: number, dTextPointX: number, dTextPointY: number): McObjectId;
	/**
	 * 绘制直径标注
	 * @param dChordPointX 弦线端点 X 坐标
	 * @param dChordPointY 弦线端点 Y 坐标
	 * @param dFarChordPointX 弦线远端点 X 坐标
	 * @param dFarChordPointY 弦线远端点 Y 坐标
	 * @param dLeaderLength 引线长度
	 * @returns 直径标注对象id
	 */
	drawDimDiametric(dChordPointX: number, dChordPointY: number, dFarChordPointX: number, dFarChordPointY: number, dLeaderLength: number): McObjectId;
	/**
	 * 绘制旋转标注
	 * @param dExtLine1PointX 第一条尺线起点 X 坐标
	 * @param dExtLine1PointY 第一条尺线起点 Y 坐标
	 * @param dExtLine2PointX 第二条尺线起点 X 坐标
	 * @param dExtLine2PointY 第二条尺线起点 Y 坐标
	 * @param dDimLineLocationX 标注线位置 X 坐标
	 * @param dDimLineLocationY 标注线位置 Y 坐标
	 * @param dRotationAngle 旋转角度，单位为弧度
	 * @returns 旋转标注对象id
	 */
	drawDimRotated(dExtLine1PointX: number, dExtLine1PointY: number, dExtLine2PointX: number, dExtLine2PointY: number, dDimLineLocationX: number, dDimLineLocationY: number, dRotationAngle: number): McObjectId;
	/**
	 * 绘制标注线性尺寸
	 * @param dDefinitionPointX - 定义点 X 坐标
	 * @param dDefinitionPointY - 定义点 Y 坐标
	 * @param dDeaderEndPointX - 标注终点 X 坐标
	 * @param dDeaderEndPointY - 标注终点 Y 坐标
	 * @param isUseXAxis - 是否沿 X 轴方向标注
	 * @returns 线性尺寸对象id
	 */
	drawDimOrdinate(dDefinitionPointX: number, dDefinitionPointY: number, dDeaderEndPointX: number, dDeaderEndPointY: number, isUseXAxis: boolean): McObjectId;
	/**
	 * 绘制标注径向尺寸
	 * @param dCenterX - 中心点 X 坐标
	 * @param dCenterY - 中心点 Y 坐标
	 * @param dChordPointX - 弦线端点 X 坐标
	 * @param dChordPointY - 弦线端点 Y 坐标
	 * @param dLeaderLength - 标注线长度
	 * @returns 径向尺寸对象id
	 */
	drawDimRadial(dCenterX: number, dCenterY: number, dChordPointX: number, dChordPointY: number, dLeaderLength: number): McObjectId;
	/**
	 * 将路径移动到指定位置
	 * @param dX - X 坐标
	 * @param dY - Y 坐标
	 */
	pathMoveTo(dX: number, dY: number): void;
	/**
	 * 移动路径到指定位置，同时指定起始宽度、终止宽度和凸度
	 * @param dX - X 坐标
	 * @param dY - Y 坐标
	 * @param dStartWidth - 起始宽度
	 * @param dEndWidth - 终止宽度
	 */
	pathMoveToEx(dX: number, dY: number, dStartWidth: number, dEndWidth: number, dBulge: number): void;
	/**
	 * 从当前位置画一条直线到指定位置
	 * @param dX - X 坐标
	 * @param dY - Y 坐标
	 */
	pathLineTo(dX: number, dY: number): void;
	/**
	 * 从当前位置画一条直线到指定位置，同时指定起始宽度、终止宽度和凸度
	 * @param dX - X 坐标
	 * @param dY - Y 坐标
	 * @param dStartWidth - 起始宽度
	 * @param dEndWidth - 终止宽度
	 * @param dBulge - 凸度
	 */
	pathLineToEx(dX: number, dY: number, dStartWidth: number, dEndWidth: number, dBulge: number): void;
	/**
	 * 根据圆对象创建一个路径
	*/
	pathCircle(dCenX: number, dCenY: number, dR: number, dPrecision?: number, dWidth?: number): boolean;
	/**
	 * 将路径转换为折线
	 * @returns 转换结果
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad"
	 *
	 *  let mxcad = MxCpp.getCurrentMxCAD();
		//绘制一个箭头
		mxcad.pathMoveToEx(1000, 300, 10, 10, 0);

		mxcad.pathLineToEx(1000, 500, 30, 0, 0);

		mxcad.pathLineTo(1000, 580);

		mxcad.drawPathToPolyline();
	 * ```
	 */
	drawPathToPolyline(): McObjectId;
	/**
	 * 将路径转换为样条曲线
	 * @returns 转换结果
	 */
	drawPathToSpline(): McObjectId;
	/**
	 * 闭合路径
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad"
	 *
	 *  let mxcad = MxCpp.getCurrentMxCAD();
		//用Plyline显示绘制矩形框

		//定义一个路径的开始点
		mxcad.pathMoveTo(0, 300);

		//路径的一下个点
		mxcad.pathLineTo(100, 300);

		//路径的一下个点
		mxcad.pathLineTo(100, 400);

		//路径的一下个点
		mxcad.pathLineTo(0, 400);

		//把路径设置成闭合
		mxcad.pathMakeClosed();

		//把路径闭合，生成一个矩形框
		mxcad.drawPathToPolyline();
	 * ```
	 */
	pathMakeClosed(): void;
	/**
	 * 将路径转换为填充图案
	 * @param dPatternScale - 图案缩放比例
	 * @returns 转换结果
	 * @example
	 * ```ts
		import { MxCADUiPrPoint, MxCADUiPrDist, MxCpp } from "mxcad";
		// 实心圆
		async function Mx_SolidCircle() {
			const getCenter = new MxCADUiPrPoint();
			getCenter.setMessage('请确定圆心位置\n');
			const center = await getCenter.go();
			if (!center) return;
			const getRadius = new MxCADUiPrDist();
			getRadius.setBasePt(center);// 设置距离基点为圆心
			getRadius.setMessage('请输入圆半径');
			getRadius.setUserDraw((pt, pw) => {
				const r = pt.distanceTo(center);
				const circle = new McDbCircle();
				circle.center = center;
				circle.radius = r;
				pw.drawMcDbEntity(circle)
			})
			const radiusVal = await getRadius.go();
			if (!radiusVal) return;
			const radius = getRadius.value();
			const mxcad = MxCpp.getCurrentMxCAD();
			mxcad.pathCircle(center.x, center.y, radius);//设置圆路径
			mxcad.drawPathToHatch();// 绘制实心圆
		}
	 * ```
	 */
	drawPathToHatch(dPatternScale?: number): McObjectId;
	/**
	 * 绘制实体
	 * @param entity - 实体对象
	 * @returns 绘制结果
	 * @example
	 * ```ts
	 * import { McDbPolyline, MxCpp } from
	 * let pl = new McDbPolyline();
	   pl.addVertexAt(new McGePoint3d(100, 100, 100));
	   pl.addVertexAt(new McGePoint3d(200, 100, 500));
	   pl.addVertexAt(new McGePoint3d(300, 400, 200));
	   MxCpp.getCurrentCAD().drawEntity(pl);
	 * ```
	 */
	drawEntity(entity: McDbEntity, isUseDatabaseCurrentProperties?: boolean): McObjectId;
	/**
	* 绘制填充对象
	* @param entity - 填充对象对象
	* @returns 绘制对象id
	* @example
	* ```ts
	* import { MxCADUiPrPoint, MxCADUtility, MxCpp, McGePoint3d } from "mxcad";
	*
		async function Mx_TestDrawHatchFormPoint() {
			const getPoint = new MxCADUiPrPoint();
			getPoint.setMessage("\n指定填充区域内部一点:");
			getPoint.disableAllTrace(true);
			getPoint.setDisableOsnap(true);
			let pt = (await getPoint.go()) as McGePoint3d;
			if (!pt) return;

			let hatch = MxCADUtility.builderHatchFromPoint(pt);
			if (!hatch) {
				MxFun.acutPrintf("\n 没有找到闭合区域")
				return;
			}

			let mxcad = MxCpp.getCurrentMxCAD();
			mxcad.addPatternDefinition("My图案", "((45, 0,0, 0,0.125))");
			mxcad.drawPatternDefinition = "My图案";
			mxcad.drawHatch(hatch, 5.0);
		}
	* ```
	*/
	drawHatch(hatch: McDbHatch, dPatternScale?: number): McObjectId;
	/**
  * 将 lIdIndex 转换成 McDbObject 对象
  * @param lIdIndex - 对象 ID
  * @returns 与 ID 对应的 McDbObject 对象，如果对象不存在则返回 null
  */
	objectIdToObject(lIdIndex: number): McDbObject | null;
	/**
	 * 销毁指定的 McRxObjectImp 对象
	 * @param pObjectImp - 待销毁的 McRxObjectImp 对象
	 * @internal
	 */
	destroyObject(pObjectImp: McRxObjectImp): void;
	/**
	* 得到所有布局名
	*/
	getAllLayoutName(): McGeStringArray;
	/**
	* 设置当前布局名
	* @param layoutName 布局名称
	*/
	setCurrentLayout(layoutName: string): boolean;
	/**
	* 得到当前布局名
	*/
	getCurrentLayout(): string;
	/**
	* 得到当前布局ID
	*/
	getCurrentLayoutId(): McObjectId;
	/**
	* 得到当前openWebFile打开的文件，的文件名，如果打开是一个流数据，该变量会取服务器返回请求头的filename的值。
	*/
	GetDocumentFileName(): string;
	/**
	 * 返回MxCpp对象，它会在MxDraw模块中调用。
	*/
	getMxCpp(): any;
	/**
   * 返回当前视区的显示范围,cad坐标。
   * @param pt1 左下角点
   * @param pt2 右下角点
   * @param pt3 右上角点
   * @param pt4 左上角点
   * @returns 当前视区显示范围
   */
	getViewCADCoord(): {
		pt1: McGePoint3d;
		pt2: McGePoint3d;
		pt3: McGePoint3d;
		pt4: McGePoint3d;
	};
	/**
	 * 更新显示
	 * @param isImmediate 是否立即更新
	 * @param delayTime 延迟更新时间
	*/
	updateDisplay(isImmediate?: boolean, delayTime?: number): void;
	/**
	* 更新图层的显示
   */
	updateLayerDisplayStatus(): void;
	/**
   * 初始化用户注册数据.
   * @param sRegist 注册数据
  */
	initRegist(sRegist: string): void;
	/**
	* 初始化用户授权服务url.
	* @param sUrl 授权服务url
	*/
	iniAuthorizedService(sUrl: string): void;
	/**
	 * 当前程序是否是试用版本.
	*/
	isTryVersion(): boolean;
	/**
	* 设置视区的背景色.
	* @param red 红色分量 (0-255)
	* @param green 绿色分量 (0-255)
	* @param blue 蓝色分量 (0-255)
	* @example
	* ```ts
	* import { MxCpp, McObject } from "mxcad"
	* const mxcad:McObject = MxCpp.getCurrentMxCAD()
	* mxcad.setViewBackgroundColor(255, 255, 255)
	* ```
   */
	setViewBackgroundColor(red: number, green?: number, blue?: number): void;
	/**
	  * 返回视区的背景色，0XFF(red)FF(green)FF(blue)
	  */
	getViewBackgroundColor(): number;
	/**
	 * 返回当前数据库中设置的绘制颜色，它会自动依据背景色，把黑白色转换。
	 * @returns 返回当前数据库中设置的绘制颜色，THREE.Color对象
	*/
	getCurrentDatabaseDrawColor(): THREE.Color;
	/**
	 * 回退到上一个命令或标记处
	*/
	undo(): void;
	/**
	 *反回退，重做。
	*/
	redo(): void;
	/**
	 *在当前设置一个回退标记.
	*/
	undoMark(): void;
	/**
	 *回退标记索引加1.
	 *在非命令函数里面修改数据据对象，需要回退标记索引加1，这样会记录修改，不然可能会认为上一次的命令修改，跳过当前修改回退记录.
	 *在命令里面会自动回退标记索引加1
	*/
	undoIndexIncrease(): void;
}
/**
 * McAppType 是 MxCAD 应用级核心入口类。
 *
 * @description
 * 该类负责封装 MxCAD 运行时的全局能力，包括应用初始化、当前 CAD 实例获取、颜色与背景设置、字体加载、对象类型转换、以及与底层 C++ 实现的交互。
 * 它是插件和扩展开发中访问 MxCAD 全局能力的主要入口。
 * 使用方法总结：
 * 1. 通过 `MxCpp.App` 获取实例；
 * 2. 使用 `getCurrentMxCAD()` 获取当前 CAD 对象；
 * 3. 调用字体、背景、对象转换等方法进行全局配置和运行时控制。
 *
 * @example
 * ```ts
 * import { MxCpp, McDbLayerTableRecord } from "mxcad";
 *
 * const app = MxCpp.App;
 * // 获取当前mxcad对象
 * const mxcad =  MxCpp.App.getCurrentMxCAD();
 * // 设置默认视区背景色为白色
 * app.setDefaultViewBackgroundColor(255, 255, 255);
 * // 设置默认字体为 Arial
 * app.setDefaultTrueTypeFontFile("Arial.ttf");
 * // 判断对象类型
 * const isCurve = app.objectIdIsKindOf(someId, "McDbCurve");
 *
 * ```
 * */
export declare class McAppType {
	/** 内部实现对象 */
	private imp;
	/**
	 * @internal
	 * MxCAD辅助,内部使用
	 */
	MxCADAssist: any;
	/** id 转换为 McDbObject */
	private objectIdToObjectCalls;
	/** 根据类型转为实例 */
	private classNameToCreateCalls;
	/** shx字体 */
	private shxFonts;
	/** shx big 字体 */
	private shxBigFonts;
	/** TrueType字体 */
	private trueFonts;
	private dMcGeBakTol;
	private iIsWasmx64;
	/**
	 * 初始化 McAppType 对象。
	 */
	init(imp: any): void;
	/**
	 * 设置McAppType的 imp 对象。
	 * @param imp 传入的 imp 对象。
	 */
	setImp(imp: any): void;
	/**
	 * 获取 imp 对象。
	 * @returns 返回 imp 对象。
	 */
	getImp(): any;
	/**
	 * 获取最后一次调用的结果。
	 * @returns 返回最后一次调用的结果
	 */
	getLastCallResult(): number;
	/**
	 * 销毁对象。
	 * @param pObject 要销毁的对象。
	 * @internal
	 */
	destroyObject(pObject: McRxObjectImp): void;
	/**
	 * 获取当前的 MxDraw 对象。
	 * @returns 返回当前的 McObject 对象。
	 * @example
	 * ```ts
	 * //添加图层
	 * import { MxCpp } from 'mxcad'
	 * // 获取当前cad对象
	 * let mxcad = MxCpp.App.getCurrentMxCAD();
	 * // 获取图层表
	 * let layerTable = mxcad.getDatabase().getLayerTable();
	 * if (!layerTable.has("xxx11")) {
	 *   let newLayer = new McDbLayerTableRecord();// 构造新图层记录对象
	 *   newLayer.name = "xxx11";// 设置新图层名为："xxx11"
	 *   layerTable.add(newLayer);// 图层表新增图层记录对象
	 * }
	 *
	 * if (layerTable.has("xxx11")) {
	 *   console.log("add layer ok");
	 * }
	 * ```
	 */
	getCurrentMxCAD(): McObject;
	/**
	 * 将 RGB 值转换为索引。
	 * @param red 红色值。
	 * @param green 绿色值。
	 * @param blue 蓝色值。
	 * @param bAutoNearest 是否自动获取最近的颜色值。
	 * @returns 返回转换后的索引值。
	 */
	mcedRGB2Index(red: number, green: number, blue: number, bAutoNearest?: boolean): number;
	/**
	 * 设置默认的视区的背景色.
	 * @param red 红色值。
	 * @param green 绿色值。
	 * @param blue 蓝色值。
	 */
	setDefaultViewBackgroundColor(red: number, green: number, blue: number): void;
	/**
	 * 判断一个对象id是否指类类型名对象
	 * @param lIdIndex 对象id索引
	 * @param className 对象名称
	 * @return 返回布尔值
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity } from "mxcad";
	 * // 选择目标对象
	 * let selEntity = new MxCADUiPrEntity();
	 * selEntity.setMessage("选择对象");
	 * let val = await selEntity.go();
	 * if (!val.isValid()) return;
	 * // 判断目标对象是为多段线类
	 * const isSuccess = MxCpp.App.objectIdIsKindOf(val.id, "McDbPolyline");
	 * if(isSuccess){
	 *   console.log("目标对象为多段线")
	 * }else{
	 *   console.log("目标对象不为多段线")
	 * }
	 * ```
	 */
	objectIdIsKindOf(lIdIndex: number, className: string): boolean;
	/**
	 * 初始化绘图环境、加载插件、设置绘图参数、创建对象等操作
	 */
	private initCalls;
	/**
	 * 将对象 id 转换为 McDbObject 对象。
	 * @param lIdIndex 对象的 id。
	 * @returns 返回转换后的 McDbObject 对象，如果转换失败，则返回 null。
	 * @example
	 * ```ts
	 * import { MxCADUiPrEntity, MxCpp } from "mxcad";
	 * // 获取目标对象
	 * let selEntity = new MxCADUiPrEntity();
	 * let val = await selEntity.go();
	 * if (!val.isValid()) return;
	 * const obj = MxCpp.App.objectIdToObject(val.id);
	 * console.log(obj)
	 * ```
	 */
	objectIdToObject(lIdIndex: number): McDbObject | null;
	/**
	 * 创建克隆对象。
	 * @param clonobjImp 被克隆的对象。
	 * @returns 返回创建的 McDbObject 对象。
	 * @internal
	 */
	createCloneObject(clonobjImp: any): McDbObject | null;
	/**
	 * 配置字体加载位置，默值是fonts
	 * @param path 字体文件路径
	 */
	setFontFilePath(path: string): void;
	/**
	 * 配置默认的TrueType字体
	 * @param sTrueTypeFontName TrueType字体名
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 * //设置默认TrueType字体为Arial.ttf
	 * mxcad.on("init_cpp", async () => {
	 *    MxCpp.App.setDefaultTrueTypeFontFile("Arial.ttf");
	 * })
	 * ```
	 */
	setDefaultTrueTypeFontFile(sTrueTypeFontName: string): void;
	/**
   * 配置默认的shx,bigshx字体
   * @param shx,bigshx shx字体名
   * @example
   * ```ts
   * import { MxCpp } from "mxcad";
   * mxcad.on("init_cpp", async () => {
   *   MxCpp.App.setDefaultShxFontFile("txt.shx","hztxt.shx");
   * })
   * ```
   */
	setDefaultShxFontFile(sShxFile: string, sBigShxFile: string): void;
	/**
	* 配置需要通过网络加载的shx字体
	* @param fontfiles 加载的字体文件
	* @example
	* ```ts
	* import { MxCpp } from 'mxcad';
	* import { MxFun } from "mxdraw";
	*
	* // MxCAD创建成功
	* MxFun.on("mxcadApplicationCreatedMxCADObject", () => {
	*   MxCpp.App.addNetworkLoadingFont( ["txt.shx","simplex.shx","aaa.shx","ltypeshp.shx","complex.shx"]);
	* }
	* ```
	*/
	addNetworkLoadingFont(fontfiles: string | string[], fontFilesLoadOnInitialization?: string[], isAddTo?: boolean): void;
	isWasmx64(): boolean;
	/**
	 * 全局参数的初始设置
	 * @description ini 初始设置值
	 * | ini对象名 | 类型 | 说明 |
	 * | ------- | ------- | ------- |
	 * | `UseUtf8` | boolean | C++ 程序是否使用 utf8 编码格式。|
	 * | `McGeTol` | number | 几何计算时点和向量相等判断精度，默认值为 `1.0E-7`。|
	 * | `EnableObjectModificationEvent` | number | `1` 启用对象增加/删除通知事件，`2` 启用对象修改通知事件，默认值为 `0`。|
	 * | `SupportTruetypeFont`| boolean | 是否支持 truetype 字体，默认值为 `true`。|
	 * | `BlockReferenceExGrip`| boolean | 块参照的外部抓手是否启用，默认值为 `false`。|
	 * | `Enable3d`| boolean |是否启用 3D 功能，默认值为 `false`。|
	 * | `ShowLayoutBackgroundPaper`| boolean | 布局背景纸张是否显示，默认值为 `true`。|
	 * | `LayoutBackgroundColor`| number | 布局背景颜色，默认值为 `0xFFFFFF`。|
	 * | `min_object_display_length`| number | 当对象显示小于该像素值时，将直接用点显示，默认值为 `1`。|
	 * @param ini 初始设置值
	 * @example
	 * ```ts
	 * import { MxCpp } from 'mxcad';
	 *
	 * // 设置全局参数
	 * MxCpp.App.IniSet({SupportTruetypeFont:false, BlockReferenceExGrip:true});
	 * ```
	 */
	IniSet(ini: any): boolean;
	/**
	* 设置几何计算时，点和向量变量判断是否相等的精度范围，默认值是1.0E-7
	*/
	setMcGeTol(dTol: number): number;
	/**
	* 恢复几何计算时，点和向量变量判断是否相等的默认精度范围值
	*/
	restoreMcGeTol(): void;
	/**
	* 配置需要通过网络加载的 bigfont 字体
	* @param fontfiles 加载的字体文件
	* @param fontFilesLoadOnInitialization 需要在初始化时加载的字体文件
	* @param isAddTo 是否追加到当前字体列表中，默认值为false
	* @example
	* ```ts
	* import { MxCpp } from 'mxcad'
	* import { MxFun } from "mxdraw";
	*
	* // MxCAD创建成功
	* MxFun.on("mxcadApplicationCreatedMxCADObject", () => {
	*   MxCpp.App.addNetworkLoadingBigFont(["hztxt.shx", "gbcbig.shx"]);
	* }
	* ```
	*/
	addNetworkLoadingBigFont(fontfiles: string | string[], fontFilesLoadOnInitialization?: string[], isAddTo?: boolean): void;
	/**
	* 配置需要通过网络加载的 Truetype 字体
	* @param fontname 字体名数组
	* @param fontzhName 字体中文名数组
	* @param fontfile 加载字体文件数组
	* @example
	* ```ts
	* import { MxCpp } from 'mxcad'
	* import { MxFun } from "mxdraw";
	*
	* // MxCAD创建成功
	* MxFun.on("mxcadApplicationCreatedMxCADObject", () => {
	*   MxCpp.App.addNetworkLoadingTrueTypeFont(["simsun","syadobe"],["思原宋体","思原黑体"],["stadobe.otf","syadobe.otf"]);
	* }
	* ```
	*/
	addNetworkLoadingTrueTypeFont(fontname: string[], fontzhName: string[], fontfile: string[], fontNamesLoadOnInitialization?: string[]): void;
	/**
	 * 得到当前支持的所有shx字体.
	 * @return 字体数组
	 */
	getShxFonts(): string[];
	/**
	 * 得到当前支持的所有bigfont shx字体.
	 * @return 字体数组
	 */
	getShxBigFonts(): string[];
	/**
	* 通知cad程序，将来要使用的字体需要加载，方便后面程序使用.
	* @param vecShxFonst shx字体
	* @param vecBigShxFonst bigfont shx字体
	* @param vecTureTypeFonts Truetype字体
	* @param retCall 回调函数
	* @example
	* ```ts
	 import { MxCpp } from 'mxcad';

	 //修改文字样式
	 function Mx_Test_TrueText(){
	 let mxcad = MxCpp.getCurrentMxCAD();
	 //清空当前显示内容
	 mxcad.newFile();
	 MxCpp.App.loadFonts([], [], ["syadobe","simsun"], () => {
		// 添加一个黑体文字样式
		mxcad.AddTureTypeTextStyle("ht_style","syadobe");
		// 添加一个宋体文字样式
		mxcad.AddTureTypeTextStyle("st_style","simsun");
		// 设置当前样式为黑体
		mxcad.drawTextStyle = "ht_style";
		mxcad.drawColor = new McCmColor(200, 255, 50);
		let idText = mxcad.drawText(0, 3500, "绘图控件TrueType文字测试", 100, 0, 0, 1);
		let ent = idText.getMcDbEntity();
		// 修改文字样式为宋体
		if(ent) ent.textStyle = "st_style";
		mxcad.zoomAll();
		mxcad.regen();
		mxcad.updateDisplay();
	   });
	 }
	* ```
	*/
	loadFonts(vecShxFonts: string[], vecBigShxFonts: string[], vecTureTypeFonts: string[], retCall: () => void): void;
	/**
	 * 得到该字体是否已经从网上加载
	 * @param sFont 字体名
	 * @param iType 字体类型 0:shx字体 1:bigshx字体 2:truetype字体
	 * @returns boolean
	*/
	isAlreadyLoaded(sFont: string, iType?: number): boolean;
	/**
	 * 得到当前支持的所有TrueType字体.
	 * @returns { object } name 字体名| zhname 字体中文名 | file 字体文件
	*/
	getTrueTypeFonts(): {
		name: string;
		zhname: string;
		file: string;
	}[];
	/**
	 * 得当前程序的版本信息
	 * @return 版本信息
	 */
	getVersionString(): string;
	/**
	 * 得当前程序的数字日期版本信息
	 * @return 数字日期版本信息
	 */
	GetVersionDateString(): string;
	/**
	 * new 一个McObjectId对象。
	 * @param id 对象id
	 * @param type 对象类型
	 * @return 返回新创建的McObjectId
	 */
	newMcObjectId(id?: number, type?: McObjectIdType): McObjectId;
}
/**
 * MxCppType 是 MxCAD 全局 API 的入口包装类。
 *
 * @description
 * 该类统一封装了 MxCAD 全局功能，包括底层程序集访问、当前 CAD 对象获取、属性窗口接口、AI 接口、几何对象创建以及字符编码转换。
 * 它让插件开发者可以通过一个统一对象访问 MxCAD 的顶层服务。
 * 使用方法总结：
 * 1. 通过 `MxCpp` 访问 `MxCppType` 实例；
 * 2. 使用 `App`、`PropertiesWindow`、`Ai` 等成员获取对应功能入口；
 * 3. 调用 `newMcGePoint3d`、`decodeFromGb2312` 等辅助方法完成常见操作。
 *
 * @example
 * ```ts
 * import { MxCpp } from "mxcad";
 *
 * const mxcad = MxCpp.getCurrentMxCAD();
 * const point = MxCpp.newMcGePoint3d({ x: 100, y: 200, z: 0 });
 * const decoded = MxCpp.decodeFromGb2312("%c4%e3%ba%c3");
 * console.log(mxcad, point, decoded);
 * ```
 * */
export declare class MxCppType {
	/**
	 * MxCpp 程序集
	 * @example
	 * ```ts
	 * //获取与修剪相关的信息
	 * import { MxCpp } from "mxcad";
	 *
	 * let mxcadTrimAssert = new MxCpp.mxcadassemblyimp.MxDrawTrimAssist()
	 * ```
	 */
	mxcadassemblyimp?: any;
	/**
	 * McAppType 实例
	 */
	App: McAppType;
	/**
	 * PropertiesWindow 属必窗口功能调用实例
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 *
	 * // 属性界面上，对象属性被修改事件。
	 * MxCpp.PropertiesWindow.onEvent_setProperties((id: McObjectId, prop: any) => {
	 *   let ent = id.getMcDbEntity();
	 *   if (!ent) return;
	 *   if (prop.sVarName == "DN") {
	 *         ent.setxDataDouble("DN", prop.val);
	 *   }
	 *  else if (prop.sVarName == "LEN") {
	 *      ent.setxDataDouble("LEN", prop.val);
	 *   }
	 * });
	 * ```
	 */
	PropertiesWindow: MxPropertiesWindowCustom;
	/**
	 * Mx AI实例
	 */
	Ai: MxAI;
	/**
	 * 获取上一次调用的结果
	 * @returns {number} 调用结果
	 */
	getCallResult(): number;
	/**
	 * 创建新的 McGePoint3d 实例
	 * @param {any} pt 点坐标
	 * @returns {McGePoint3d} McGePoint3d 实例
	 */
	newMcGePoint3d(pt?: any): McGePoint3d;
	/**
	 * 创建新的 McGeVector3d 实例
	 * @param {any} pt 点坐标
	 * @returns {McGeVector3d} McGeVector3d 实例
	 */
	newMcGeVector3d(pt?: any): McGeVector3d;
	/**
	 * 返回当前活动的CAD对象
	 */
	getCurrentMxCAD(): McObject;
	/**
	 * 返回当前活动的CAD对象
	 */
	get mxcad(): McObject;
	/**
	* 返回当前活动的CAD对象的数据库对象.
	*/
	get currentDatabase(): McDbDatabase;
	/**
	 * 返回当前活动的CAD对象的数据库对象.
	 */
	getCurrentDatabase(): McDbDatabase;
	/**
	 * 把hex格式的Gb2312编码的转成utf8
	 * @param strHex Gb2312编码
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 *
	 * const gb2312Hex = "%c4%e3%ba%c3";
	 * const decodedString = MxCpp.decodeFromGb2312(gb2312Hex);
	 * console.log("Decoded string from GB2312 hex:", decodedString);
	 * ```
	 */
	decodeFromGb2312(strHex: string): string;
	/**
	 * 把utf8转成hex格式的Gb2312编码
	 * @param str 字符串
	 * @example
	 * ```ts
	 * import { MxCpp } from "mxcad";
	 * const stringToEncode = "你好";
	 * const encodedHex = MxCpp.encodeToGb2312(stringToEncode);
	 * console.log("Encoded string to GB2312 hex:", encodedHex);
	 * ```
	 */
	encodeToGb2312(str: string): string;
	/**
	* 得到cpp转过的id
	*/
	getIdFromCpp(id: number | string): any;
}
/**
 * MxCADUI 定义了插件与 MxCAD 主应用间的宿主交互接口。
 *
 * @description
 * 该接口提供插件初始化、文件上传、宿主配置查询和当前 MxCAD 对象访问能力。
 * 通过它，插件可以获取下载配置、上传文件、判断运行环境，并访问当前 CAD 与地图对象。
 * 使用方法总结：
 * 1. 在插件初始化时由宿主传入 `MxCADUI` 实例；
 * 2. 调用 `init(plugin)` 完成插件注册；
 * 3. 使用 `uploadFile`、`getUploadFileConfig`、`isMxCADAppLib` 等方法与宿主交互。
 *
 */
export interface MxCADUI {
	/**
	 * 获取文件下载配置
	 */
	getUploadFileConfig: () => {
		baseUrl: string;
		saveDwgUrl: string;
		mxfilepath: string;
		saveUrl: string;
		printPdfUrl: string;
		cutDwgUrl: string;
	};
	/**
	* 获取mxServerConfig.json文件配置
	*/
	getServerConfig: () => any;
	/**
	 * 初始化
	 * @param plugin 基础配置
	 */
	init: (plugin: MxCADPluginBase) => void;
	/**
	* 上传一个文件，并格式转换，然用于后续处理。
	*/
	uploadFile: (uploadFile_call: (param: any) => void, isReloadFile: boolean) => void;
	/**
	* 当前程序是否在MxCADAppNpm打包模式下运行。
	*/
	isMxCADAppLib: () => boolean;
	/**
	 * mxcad对象
	 */
	mxcad: McObject;
	/**
	 * mxmap对象
	 */
	mxmap: MxMap;
}
/**
 * MxCADPluginMapDefaultData 表示地图与 CAD 图纸对齐的默认配置。
 *
 * @description
 * 该类用于描述地图与 CAD 图纸之间的对齐关系，包括 CAD 原点、地图原点、单位换算、默认打开文件、瓦片图层等信息。
 * 它常用于插件或地图集成场景，确保 CAD 内容与地图画布正确配准。
 * 使用方法总结：
 * 1. 构造 `MxCADPluginMapDefaultData` 实例；
 * 2. 设置 `cadOrigin`、`mapOrigin`、`meterInCADUnits` 等对齐参数；
 * 3. 将它作为插件配置的一部分传递给宿主。
 *
 * @example
 * ```ts
 * //设置地图加载的缺省数据
 * import { MxCADPluginMapDefaultData } from "mxcad";
 *
 * let map_default_data = new MxCADPluginMapDefaultData();
 * // CAD图纸与地图的对齐点.
 * map_default_data.cadOrigin = [116275.977014, 19273.279085];
 *
 * // 12698436.047373507,2575109.229937706,12698641.731873507,2575240.5864377064
 * // 地图与CAD图纸的对齐位置 。
 * map_default_data.mapOrigin = [114.06825863001939, 22.54283198132819];
 * // CAD图上一个绘图单是地图上多少米.
 * map_default_data.meterInCADUnits = 1.0;
 * // 需要打开的cad图纸.
 * map_default_data.openFile = './demo/road.dwg.mxweb'
 * ````
 */
export declare class MxCADPluginMapDefaultData {
	/**  地图与CAD图纸的对齐位置 */
	mapOrigin: number[];
	/** CAD图纸与地图的对齐点 */
	cadOrigin: number[];
	meterInCADUnits: number;
	/** mapbox地图token */
	mapbox_accessToken: string;
	/** 需要打开的cad图纸 */
	openFile?: string;
	/** 栅格瓦片图层列表 */
	rasterTileLayerList: any[];
	/** 矢量瓦片关键词*/
	rasterTileKey?: string;
	providers?: any;
	/** 背景颜色 */
	viewColor?: {
		red: number;
		green: number;
		blue: number;
	};
}
/**
 * MxCADUI 模块提供的示例代码
 */
/**
 * MxCADPluginSampleCode 表示插件示例代码项。
 *
 * @description
 * 该类用于在插件配置或样例集中描述一段示例代码，包含所属类型、示例名称以及代码内容。
 * 常用于文档展示、示例管理或在插件配置界面提供可复制的参考代码片段。
 * 使用方法总结：创建实例并填充 `type`、`name`、`code` 字段，随后将其加入插件配置的 `sampleCode` 列表中。
 *
 * @example
 * ```ts
 * import { MxCADPluginSampleCode } from "mxcad";
 *
 * const sample = new MxCADPluginSampleCode();
 * sample.type = "drawing";
 * sample.name = "draw-line";
 * sample.code = `const id = mxcad.drawLine(0,0,100,100);`;
 * // 将示例加入插件配置
 * // plugin.sampleCode = [ sample ];
 * ```
 */
export declare class MxCADPluginSampleCode {
	/**  示例代码在那个类型中 */
	type: string;
	/**  示例代码在名称 */
	name: string;
	/** 示例代码内容 */
	code: string;
}
/**
 * MxCADPluginBase 表示插件的基础配置结构。
 *
 * @description
 * 该类封装插件注册与初始化时所需的基础配置项，包括插件注册数据、宿主 UI 接口、
 * 默认打开文件和地图对齐配置，以及示例代码列表。
 * 它通常用于插件初始化前的参数构造和宿主注册数据传递。
 * 使用方法总结：
 * 1. 构造 `MxCADPluginBase` 实例；
 * 2. 填写 `sRegistData`、`mxcadui`、`openFile`、`map_default_data` 等字段；
 * 3. 将此对象传递给宿主的 `MxCADUI.init(plugin)` 方法完成插件初始化。
 * */
export declare class MxCADPluginBase {
	/** 注册数据 */
	sRegistData: string;
	/**插件程序使用的接口  */
	mxcadui?: MxCADUI;
	/** 打开的文件 */
	openFile?: string;
	/** 地图默认配置 */
	map_default_data?: MxCADPluginMapDefaultData;
	/** 示例代码 */
	sampleCode?: MxCADPluginSampleCode[];
}
/** 自定义属性窗口的值的类型 */
export declare enum MxPropertiesWindowCustomValueType {
	/** 整数 */
	kInt = 1,
	/** 双精度浮点数 */
	kDouble = 2,
	/** 字符串 */
	kString = 3
}
/**
 * MxPropertiesWindowCustomValue 表示属性窗口中单个自定义属性项的值描述。
 *
 * @description
 * 该类用于在属性窗口中描述一个自定义属性项，包括属性名称、类型、具体值以及是否只读。
 * 该结构可用于属性读取回调、属性设置回调或对象自定义属性同步。
 * 使用方法总结：
 * 1. 创建 `MxPropertiesWindowCustomValue` 实例；
 * 2. 设置 `sVarName`、`iVarType`、`val`、`isOnlyRead` 等字段；
 * 3. 将其返回给 `MxPropertiesWindowCustom.getEntityProperties` 或传入 `setEntityProperties`。
 *
 */
export declare class MxPropertiesWindowCustomValue {
	/** 自定义属性窗口名 */
	sVarName: string;
	/** 自定义属性窗口类型 */
	iVarType: number;
	/** 自定义属性窗口值 */
	val: any;
	/** 是否只读 */
	isOnlyRead: boolean;
}
/**
 * MxPropertiesWindowCustom 提供属性窗口自定义属性注册和读取接口。
 *
 * @description
 * 该类用于插件向属性窗口注册自定义属性回调、设置对象的自定义属性支持状态，以及读取和写入实体的自定义属性值。
 * 它是实现对象属性扩展、属性面板自定义展示与编辑的重要桥梁。
 * 使用方法总结：
 * 1. 调用 `onEvent_getProperties` 注册属性读取函数；
 * 2. 调用 `onEvent_setProperties` 注册修改函数；
 * 3. 使用 `setEntitySupportCustom`、`getEntityProperties`、`setEntityProperties` 与实体交互。
 *
 * @example
 * ```ts
 * import { MxCpp, MxPropertiesWindowCustomValueType, McObjectId } from "mxcad";
 *
 * MxCpp.PropertiesWindow.onEvent_getProperties((id: McObjectId) => {
 *   const ent = id.getMcDbEntity();
 *   if (!ent) return [];
 *   return [{
 *     sVarName: "DN",
 *     iVarType: MxPropertiesWindowCustomValueType.kDouble,
 *     val: ent.getxDataDouble("DN").val,
 *     isOnlyRead: false
 *   }];
 * });
 * ```
 * */
export declare class MxPropertiesWindowCustom {
	private getPropertiesCall;
	private setPropertiesCall;
	/**
	 * 插件程序程序调用，注册返回对象自定属性函数。
	 * @example
	 * ```ts
	 * import { MxCpp, MxPropertiesWindowCustomValueType, McObjectId} from "mxcad";
	 *
	   // 属性界面上，得到对象属性事件。
		MxCpp.PropertiesWindow.onEvent_getProperties((id: McObjectId) => {
			let ent = id.getMcDbEntity();
			if (!ent) return [];
			let dn = ent.getxDataDouble("DN");
			let len = ent.getxDataDouble("LEN");
			let ret = [];

			if (dn.ret) {
				ret.push({
					sVarName: "DN",
					iVarType: MxPropertiesWindowCustomValueType.kDouble,
					val: dn.val,
					isOnlyRead: false
				});
			}

			if (len.ret) {
				ret.push({
					sVarName: "LEN",
					iVarType: MxPropertiesWindowCustomValueType.kDouble,
					val: len.val,
					isOnlyRead: false
				});
			}
			return ret;
		})
	 * ```
	 */
	onEvent_getProperties(call: (id: McObjectId) => MxPropertiesWindowCustomValue[]): void;
	/**
	 * 插件程序程序调用，注册设置对象自定属性函数。
	 * @example
	 * ```ts
	   // 属性界面上，对象属性被修改事件。
		MxCpp.PropertiesWindow.onEvent_setProperties((id: McObjectId, prop: any) => {
			let ent = id.getMcDbEntity();
			if (!ent) return;
			if (prop.sVarName == "DN") {
				ent.setxDataDouble("DN", prop.val);
			}
			else if (prop.sVarName == "LEN") {
				ent.setxDataDouble("LEN", prop.val);
			}
		});
	 * ```
	 */
	onEvent_setProperties(call: (id: McObjectId, prop: MxPropertiesWindowCustomValue) => void): void;
	/**
	 * 插件程序程序调用，设置该对象状态支持自定义属性在属性窗口显示。
	 * @example
	 * ```ts
	   import { MxCADUiPrEntity, MxCpp } from "mxcad";

	   // 设置对象扩展属性值。
	   async function Mx_TestExProp() {
		 let selEntity1 = new MxCADUiPrEntity();

		 selEntity1.setMessage("选择要需要开启自定义属性的对象");
		 let idText = await selEntity1.go();
		 if (!idText.isValid()) return;

		 let ent = idText.getMcDbEntity();
		 MxCpp.PropertiesWindow.setEntitySupportCustom(idText);

		 // 设置对象扩展属性值。
		 ent.setxDataDouble("DN", 100);
		 ent.setxDataDouble("LEN", 2000);
	   }
	 * ```
	 */
	setEntitySupportCustom(id: McObjectId, isCustomProperties?: boolean): void;
	/** 属性UI程序调用，获取给定实体的自定义属性 */
	getEntityProperties(id: McObjectId): MxPropertiesWindowCustomValue[];
	/** 属性UI程序调用，设置给定实体的自定义属性 */
	setEntityProperties(id: McObjectId, prop: MxPropertiesWindowCustomValue): void;
}
/**
 * MxCompare 用于比较当前 CAD 显示内容与基准数据库之间的差异。
 *
 * @description
 * 该类会执行图纸比较操作，识别新增、删除、修改等对象差异，并返回对比结果。
 * 它适用于版本审查、差异标注、变更检查等场景。
 * 使用方法总结：
 * 1. 创建 `MxCompare` 实例；
 * 2. 调用 `do(base_database)` 执行比较；
 * 3. 调用 `getResult()` 获取比较结果，并可使用 `regenDisplay()` 可视化差异。
 *
 * @example
 * ```ts
 * import { MxCpp, MxCompare } from "mxcad";
 *
	function Mx_MxCompare() {
		let mxcad = MxCpp.getCurrentMxCAD();

		// 把要比较的图纸，当前背景加载当前内存中，方便查看不样的地方.
		let fileUrl = new URL("../assets/testbj.dwg.mxweb", import.meta.url).href;

		mxcad.mxdraw.makeCurrent();
		mxcad.loadDwgBackground(fileUrl, (isok: boolean) => {
			let backgroundEntity = mxcad.getBackgroundEntity();

			// 暂时隐藏背景图纸的显示。
			backgroundEntity.setShow(fileUrl, false);
			let database = backgroundEntity.getBackgroundDatabase(fileUrl);
			if (database == null) {
				return;
			}
			// 开始把当前图纸与背景图纸进行比较。
			let cmp = new MxCompare();

			if (cmp.do(database)) {
				// 得到比较结果.
				let result = cmp.getResult();
				if (result.length > 0) {
					//比较有差别，把底图显示出来，方更查看不一样的地方。
					backgroundEntity.setShow(fileUrl, true);
				}
				let colors = { "add_color": 0xFF0000, "erase_color": 0x00FF00, "modify_color": 0x0000FF, "not_modify_color": 0x505050 };

				cmp.regenDisplay(JSON.stringify(colors));
				mxcad.updateDisplay();
				console.log(JSON.stringify(result));
			}
		}, 0xc90696969, false)
	}
 * ```
 */
export declare class MxCompare {
	private imp;
	private result;
	constructor();
	private getTypeString;
	/**
	* 把当前控件显示的内容和 base_database 的图纸进行比较。
	*
	* 其中 base_database 可视为原始图纸，当前控件上新增绘制的对象会被视为新增内容。
	*
	* @param base_database 原始图纸数据库。
	* @returns 是否成功执行比较。
	*/
	do(base_database: McDbDatabase): boolean;
	/**
	* 得到图纸比较结果
	* 返回结果[{"id":被修改对象的id,"id_current":当前图纸该对象id,"id_base":原始图纸，该对象id,"pos":修改位置,"type":修改方式,"str":修改说明},...]
	*/
	getResult(): any[];
	/**
	* 根据当前比较结果重新生成显示，并以不同颜色标注差异位置。
	*
	* - 修改对象用粉色标注；
	* - 新增对象用绿色标注；
	* - 删除对象用红色标注。
	*
	* @param strColor 可选的颜色配置字符串，例如：
	*   {"add_color":0xFF0000,"erase_color":0x00FF00,"modify_color":0x0000FF,"not_modify_color":0x505050}
	* @returns 是否成功执行重绘。
	*/
	regenDisplay(strColor?: string): boolean;
}
/**
 * MxModifyColor 用于临时修改 CAD 对象的显示颜色。
 *
 * @description
 * 该类不会改变对象本身属性，而是通过临时显示方式批量修改对象颜色，适用于差异标注、审图预览、效果展示等场景。
 * 它可以快速应用颜色变更并随后恢复原始显示状态。
 * 使用方法总结：
 * 1. 创建 `MxModifyColor` 实例；
 * 2. 调用 `Do(database, color)` 执行颜色修改；
 * 3. 需要恢复时调用 `DoRestore()`。
 *
 * @example
 * ```ts
 * // 临时修改所有对象的颜色为白色，再次调用恢复原始颜色。
 * import { MxCpp, McCmColor, ColorIndexType } from "mxcad";
 *
   let modify: any;

   function Mx_Test_ModifyAllEntityColor() {
		if (modify) {
			modify.DoRestore();
			modify = undefined;
		}
		else {
			modify = new MxModifyColor();
			let color = new McCmColor();
			color.setColorIndex(ColorIndexType.kWhite);
			modify.Do(MxCpp.getCurrentDatabase(), color);
		}
   }
 * ```
 */
export declare class MxModifyColor {
	private imp;
	constructor();
	/**
	* 修改指定数据库中对象的显示颜色。
	*
	* @param database 目标数据库。
	* @param color 目标颜色。
	* @returns 是否成功执行修改。
	*/
	Do(database: McDbDatabase, color: McCmColor): boolean;
	/**
	* 恢复之前被临时修改的对象颜色。
	*/
	DoRestore(): void;
}
/**
 * MxCADTempForbiddenIntelliSelect 用于临时禁用智能选择功能。
 *
 * @description
 * 适用于需要在特定流程中避免对象被自动智能选中的场景，例如自定义交互、
 * 录制操作或执行批量绘制时。
 *
 * @example
 * ```ts
 * import { MxCpp, MxCADTempForbiddenIntelliSelect } from "mxcad";
 *
	let forbiddenIntelliSelect: MxCADTempForbiddenIntelliSelect | undefined;
   
	if (forbiddenIntelliSelect) {
		(forbiddenIntelliSelect as MxCADTempForbiddenIntelliSelect).restoreSettings();
		forbiddenIntelliSelect = undefined;
	}
	else {
		forbiddenIntelliSelect = new MxCADTempForbiddenIntelliSelect(true);
	}
 * ```
 */
export declare class MxCADTempForbiddenIntelliSelect {
	private bakIsIntelliSelect;
	constructor(isForbidden?: boolean);
	/**
	 * 恢复之前保存的智能选择设置。
	 */
	restoreSettings(): void;
}
/**
 * MxCooperate 提供 MxCAD 的协同工作功能封装。
 *
 * @description
 * 该类支持创建协作会话、查询协作列表、加入/退出协作、初始化协作服务端参数，并监听协作状态变化。
 * 它适用于多人实时协作、远程共享图纸、协同编辑与网络同步场景。
 * 使用方法总结：
 * 1. 通过 `MxCpp.mxcad.getCooperate()` 获取实例；
 * 2. 调用 `createWork`、`joinWork` 等接口进入协作；
 * 3. 注册 `onEvent` 监听协作状态，并根据需要调用 `exitWork()` 退出。
 *
 * @example
 * ```ts
 * // 创建协同工作并监听事件
 *
 * import { MxCpp } from "mxcad";
 *
 * function Mx_Cooperate_OnEvent(){
		let cooperate = MxCpp.mxcad.getCooperate();
		cooperate.onEvent((eventName: string, iRet: number)=>{
			if(eventName == "cooperate_joinWork_complete"){
				if(iRet == 0){
					console.log("cooperate_joinWork_complete");
				}
				else{
					console.log("cooperate_joinWork_complete return failed,error code:" + iRet);
				}
			}
			else if(eventName == "cooperate_work_network_disconnection"){
				console.log("cooperate_work_network_disconnection");
			}
		})
	}
	function Mx_Cooperate_Create() {
		let cooperate = MxCpp.mxcad.getCooperate();
		let workName = "TestWork";
		let userId = "54134";
		let userData = "TestData";
		cooperate.createWork((workid:number) => {
			if (workid > 0) {
				console.log("create cooperate ok,work name:" + workName + ",id:" + workid);
			}
			else {
				let lErrorCode  = -workid;
				console.log("create cooperate failed,error code:" + lErrorCode);
				if(lErrorCode == 4){
					console.log("create cooperate Has been created");
				}
			}
		},workName,userId,userData);
	
		Mx_Cooperate_OnEvent();
	}
 * ```
 */
export declare class MxCooperate {
	private mxcad;
	constructor(mxcad: McObject);
	/**
	*创建协同工作
	*/
	createWork(retCall?: (wrokId: number) => void, sWorkData?: string, sUserId?: string, sUserData?: string): number;
	/**
	* 获取当前正在协同的工作列表。
	*
	* @param retCall 回调函数，返回当前协同工作列表。
	* @returns 请求结果代码。
	*/
	getWorks(retCall: (works: any[]) => void): number;
	/**
	*创建协同工作
	*/
	joinWork(workId: number, retCall?: (iRet: number) => void, sUserId?: string, sUserData?: string): number;
	/**
	* 初始化协同工作的服务端参数。
	*
	* 例如：{ server_addres: "http://localhost:3091" }
	*
	* @param param 初始化参数对象。
	*/
	init(param: object): any;
	/**
	* 退出当前协同工作。
	* @returns 操作结果代码。
	*/
	exitWork(): number;
	/**
	* 获取当前协同工作的状态。
	* @returns 协同状态编码。
	*/
	getStatus(): number;
	/**
	* 注册协同工作事件回调。
	*
	* @param retCall 事件处理回调，接收事件名和结果码。
	*/
	onEvent(retCall: (eventName: string, iRet: number) => void): void;
}
/**
 * 指定执行克隆操作时的行为类型
 */
export declare enum MxCADCloneType {
	/** 正常Clone */
	kClone = 1,
	/** 动态拖动Clone */
	kDragClone = 2,
	/** 数据归档 */
	kCPPClone = 3
}
/**
 * CADWorldDraw类型
 */
export declare enum MxCADWorldDrawType {
	/** 正常WorldDraw */
	kWorldDraw = 1,
	/** 打碎对象时调用的WorldDraw */
	kExplodeDraw = 2
}
/**
 * DWG 字段读写接口，用于在自定义实体与 AutoCAD 文件格式之间同步属性数据。
 *
 * @description
 * 该类提供了统一的字段访问接口，用于把自定义实体中的几何数据和属性数据按名称写入或读取 DWG 文件。
 * 在自定义实体开发中，通常需要实现：
 * - `writePoint / readPoint`：处理 McGePoint3d 类型字段；
 * - `writePoints / readPoints`：处理点数组字段；
 * - `writeLong / readLong`：处理整型值；
 * - `writeDouble / readDouble`：处理浮点数；
 * - `writeString / readString`：处理字符串。
 *
 * 通过这个接口，开发者可以让自定义实体在保存、克隆、加载 DWG 文件时保持数据一致，避免运行时状态丢失。
 *
 * 使用方式：
 * 1. 继承 `McDbCustomEntity` 并在 `dwgInFields()` 中读取字段；
 * 2. 在 `dwgOutFields()` 中将对象属性写回过滤器；
 * 3. 结合自定义实体注册和绘制逻辑实现，完成对象持久化和恢复。
 *
 * 总结：`IMcDbDwgFiler` 是自定义实体数据持久化的桥接接口，负责把 JavaScript 侧对象状态与 DWG 文件中的字段数据相互转换。
 *
 * @example
 * ```ts
 * import { McDbCustomEntity, IMcDbDwgFiler, McGePoint3d } from "mxcad";
 *
 * class McDbTestLineCustomEntity extends McDbCustomEntity {
 *   private pt1: McGePoint3d = new McGePoint3d();
 *   private pt2: McGePoint3d = new McGePoint3d();
 *
 *   public create(imp?: any): McDbCustomEntity {
 *     return new McDbTestLineCustomEntity(imp);
 *   }
 *
 *   public getTypeName(): string {
 *     return "McDbTestLineCustomEntity";
 *   }
 *
 *   public dwgInFields(filter: IMcDbDwgFiler): boolean {
 *     this.pt1 = filter.readPoint("pt1").val;
 *     this.pt2 = filter.readPoint("pt2").val;
 *     return true;
 *   }
 *
 *   public dwgOutFields(filter: IMcDbDwgFiler): boolean {
 *     filter.writePoint("pt1", this.pt1);
 *     filter.writePoint("pt2", this.pt2);
 *     return true;
 *   }
 *
 *   public worldDraw(draw: any): void {
 *     // 自定义绘制逻辑
 *   }
 * }
 * ```
 */
export declare abstract class IMcDbDwgFiler {
	/**
	 * 指定对象克隆类型为正常克隆
	 */
	private type;
	/**
	 * 构造函数
	 * @param type 克隆类型
	 */
	constructor(type: MxCADCloneType);
	/**
	 * 获取对象的类型信息
	 * @returns 克隆类型
	 */
	getType(): MxCADCloneType;
	/**
	 * 向已打开的 DWG 文件中写入一组点对象。
	 * @param name 点对象数组名称
	 * @param vals 点对象数组
	 */
	writePoints(name: string, vals: McGePoint3d[]): void;
	/**
	 * 从打开的 DWG 文件中读取一组点对象。
	 * @param name 点对象数组名称
	 * @returns { Object } ret 是否成功获取 | val 点对象数组
	 */
	readPoints(name: string): {
		val: McGePoint3d[];
		ret: boolean;
	};
	/**
	 * 向已打开的 DWG 文件中写入一个点对象。
	 * @param name 点对象名称
	 * @param val 点对象
	 */
	abstract writePoint(name: string, val: McGePoint3d): void;
	/**
	 * 从打开的 DWG 文件中读取一个点对象。
	 * @param name 点对象名称
	 * @returns { Object } ret 是否成功获取 | val 点对象数组
	 */
	abstract readPoint(name: string): {
		val: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 向已打开的 DWG 文件中写入一个长整数。
	 * @param name 长整数名称
	 * @param val 长整数值
	 */
	abstract writeLong(name: string, val: number): void;
	/**
	 * 从打开的 DWG 文件中读取一个长整数。
	 * @param name 长整数名称
	 * @returns { Object } ret 是否成功获取 | val 长整数值
	 */
	abstract readLong(name: string): {
		val: number;
		ret: boolean;
	};
	/**
	 * 向已打开的 DWG 文件中写入一个浮点数。
	 * @param name 浮点数名称
	 * @param val 浮点数值
	 */
	abstract writeDouble(name: string, val: number): void;
	/**
	 * 从打开的 DWG 文件中读取一个浮点数。
	 * @param name 浮点数名称
	 * @returns { Object } ret 是否成功获取 | val 浮点数值
	 */
	abstract readDouble(name: string): {
		val: number;
		ret: boolean;
	};
	/**
	 * 向已打开的 DWG 文件中写入一个字符串。
	 * @param name 字符串名称
	 * @param val 字符串值
	 */
	abstract writeString(name: string, val: string): void;
	/**
	 * 从打开的 DWG 文件中读取一个字符串。
	 * @param name 字符串名称
	 * @returns { Object } ret 是否成功获取 | val 字符串值
	 */
	abstract readString(name: string): {
		val: string;
		ret: boolean;
	};
}
/**
 * MxCAD 的绘图上下文，用于在自定义实体的 worldDraw 阶段执行图形渲染与图层设置。
 *
 * @description
 * 该类封装了底层绘图设备的调用入口，提供了 drawEntity、drawOsnapEntity、set trueColor、set lineWeight 等能力，
 * 用于在 AutoCAD 中进行自定义图形的显示、捕捉和样式控制。
 * 常见用途包括：
 * - 绘制多段线、圆、文字等实体；
 * - 设置当前颜色、线型、线宽和图层；
 * - 根据自定义实体的几何数据进行重绘；
 * - 处理对象的捕捉和显示效果。
 *
 * 使用方式：
 * 1. 在自定义实体的 worldDraw(draw: MxCADWorldDraw) 方法中获取当前绘图上下文；
 * 2. 调用 drawEntity() 或 drawOsnapEntity() 绘制实体；
 * 3. 通过 trueColor、layerId、lineTypeScale 等属性设置渲染状态；
 * 4. 在需要时使用 getDatabase() 获取当前数据库环境。
 *
 * 总结：MxCADWorldDraw 是自定义实体渲染的核心入口，开发者通常在 worldDraw 中使用它来将对象真正显示在 CAD 界面中。
 *
 * @example
 * ```ts
 * import { McDbCustomEntity, McDbPolyline, McGePoint3d, MxCADWorldDraw } from "mxcad";
 *
 * class McDbTestLineCustomEntity extends McDbCustomEntity {
 *   private pt1: McGePoint3d = new McGePoint3d();
 *   private pt2: McGePoint3d = new McGePoint3d();
 *
 *   public create(imp?: any): McDbCustomEntity {
 *     return new McDbTestLineCustomEntity(imp);
 *   }
 *
 *   public getTypeName(): string {
 *     return "McDbTestLineCustomEntity";
 *   }
 *
 *   public dwgInFields(filter: any): boolean { return true; }
 *   public dwgOutFields(filter: any): boolean { return true; }
 *
 *   public worldDraw(draw: MxCADWorldDraw): void {
 *     const pl = new McDbPolyline();
 *     pl.addVertexAt(this.pt1);
 *     pl.addVertexAt(this.pt2);
 *     pl.addVertexAt(new McGePoint3d(0, 10, 0));
 *     draw.drawEntity(pl);
 *   }
 * }
 * ```
 */
export declare class MxCADWorldDraw {
	/** 内部对象实现 */
	imp: any;
	/** 内部对象实现 */
	private type;
	/**
	 * 构造函数
	 * @param lPtrWorldDraw 传递指向绘图设备的指针
	 */
	constructor(lPtrWorldDraw: number);
	/**
	 * 返回worddraw当前绘制的数据库。
	 */
	getDatabase(): McDbDatabase;
	/**
	 *使Draw对象使用使用entity的属性
	 */
	setupForEntity(entity: McDbEntity): boolean;
	/**
	 * 绘制实例对象
	 */
	drawEntity(entity: McDbEntity): void;
	/**
	 * 绘制一个用于捕捉使用的对象.
	 */
	drawOsnapEntity(entity: McDbEntity): void;
	/**
	 * 设置或获取颜色
	 * @param val 颜色对象（McCmColor）
	 */
	set trueColor(val: McCmColor);
	get trueColor(): McCmColor;
	/**
	* 设置或获取当前使用的图层
	* @param val 图层id
	*/
	set layerId(val: McObjectId);
	get layerId(): McObjectId;
	/**
	* 设置或获取当前使用的线型id
	* @param val 线型id
	*/
	set lineTypeId(val: McObjectId);
	get lineTypeId(): McObjectId;
	/**
	* 设置或获取当前使用的线重
	* @param val 使用的线重
	*/
	set lineWeight(val: McDb.LineWeight);
	get lineWeight(): McDb.LineWeight;
	/**
	 * 设置或获取当前使用的线型比例
	 * @param val 线型比例
	 */
	set lineTypeScale(val: number);
	get lineTypeScale(): number;
	/**
	* 得到worddraw type
	*/
	getType(): MxCADWorldDrawType;
	/**
	 * 初始化worddraw type
	 */
	initType(type: MxCADWorldDrawType): void;
}
/**
 * 自定义实体基类，用于在 MxCAD 中扩展新的实体类型并实现自定义绘制、数据持久化与编辑行为。
 *
 * @description
 * McDbCustomEntity 是所有自定义 CAD 实体的基类，通常用于创建具有特殊几何结构、扩展属性或特殊交互逻辑的对象。
 * 这个类允许开发者自定义：
 * - 实体类型名称和实例创建逻辑；
 * - DWG 文件中的字段读写逻辑；
 * - 图形绘制逻辑；
 * - 夹点编辑和对象变换逻辑；
 * - 对象克隆和同步到底层 C++ 数据的行为。
 *
 * 通过继承它，开发者可以创建例如自定义标注、符号、特征线、轮廓线等非标准实体，并把它们接入 MxCAD 的数据库和渲染流程中。
 *
 * 使用方式：
 * 1. 继承 McDbCustomEntity 并实现 getTypeName()、create()；
 * 2. 在 dwgInFields() / dwgOutFields() 中同步自定义属性；
 * 3. 在 worldDraw() 中使用 MxCADWorldDraw 完成绘制；
 * 4. 如需编辑，重写 moveGripPointsAt()、getGripPoints() 等方法；
 * 5. 使用 rxInit() 注册自定义实体，随后通过命令创建对象。
 *
 * 总结：McDbCustomEntity 是 MxCAD 自定义实体开发的核心抽象类，负责把对象的几何、属性和渲染行为统一封装在一起，方便开发者扩展 CAD 功能。
 *
 * @example
 * ```ts
	import { IMcDbDwgFiler, McDbCustomEntity, McDbEntity, McDbLine, McGeMatrix3d, McGePoint3d, McGePoint3dArray, MxCADUiPrPoint, MxCADWorldDraw, MxCpp } from "mxcad";

	class McDbTestLine extends McDbCustomEntity {

		private pt1: McGePoint3d = new McGePoint3d();
		private pt2: McGePoint3d = new McGePoint3d();
		private matrix: McGeMatrix3d = new McGeMatrix3d()

		constructor(imp?: any) {
			super(imp);
		}

		public create(imp: any) {
			return new McDbTestLine(imp)
		}

		public getTypeName(): string {
			return "McDbTestLine";
		}

		public dwgInFields(filter: IMcDbDwgFiler): boolean {
			this.pt1 = filter.readPoint("pt1").val;
			this.pt2 = filter.readPoint("pt2").val;
			const matrixStr = filter.readString("matrix").val;
			const matrixData = JSON.parse(matrixStr) as number[][];

			// 重建矩阵数据
			for (let i = 0; i < matrixData.length; i++) {
				for (let j = 0; j < matrixData[i].length; j++) {
					this.matrix.setData(i, j, matrixData[i][j]);
				}
			}
			return true;
		}

		public dwgOutFields(filter: IMcDbDwgFiler): boolean {
			filter.writePoint("pt1", this.pt1);
			filter.writePoint("pt2", this.pt2);
			const matrix: number[][] = [];
			for (let i = 0; i < 4; i++) {
				matrix[i] = [];
				for (let j = 0; j < 4; j++) {
					matrix[i][j] = this.matrix.getData(i, j);
				}
			}
			filter.writeString("matrix", JSON.stringify(matrix));
			return true;
		}

		public moveGripPointsAt(iIndex: number, dXOffset: number, dYOffset: number, dZOffset: number) {
			this.assertWrite();
			if (iIndex == 0) {
				this.pt1.x += dXOffset;
				this.pt1.y += dYOffset;
				this.pt1.z += dZOffset;
			}
			else if (iIndex == 1) {
				this.pt2.x += dXOffset;
				this.pt2.y += dYOffset;
				this.pt2.z += dZOffset;
			}
		};

		public getGripPoints(): McGePoint3dArray {
			let ret = new McGePoint3dArray()
			ret.append(this.pt1);
			ret.append(this.pt2);
			return ret;
		};

		public worldDraw(draw: MxCADWorldDraw): void {
			let tmpline = new McDbLine(this.pt1, this.pt2);
			tmpline.transformBy(this.matrix)
			draw.drawEntity(tmpline);
		}

		public setPoint1(pt1: McGePoint3d) {
			this.assertWrite();
			this.pt1 = pt1.clone();
		}

		public setPoint2(pt2: McGePoint3d) {
			this.assertWrite();
			this.pt2 = pt2.clone();
		}

		public getPoint1() {
			return this.pt1;
		}

		public getPoint2() {
			return this.pt2;
		};

		// 编辑变换(也可直接记录下转换矩阵在动态渲染中执行)
		public transformBy(mat: McGeMatrix3d): boolean {
			this.matrix = this.matrix.preMultBy(mat);
			this.assertWrite();
			return true;
		};
		// 包围盒输出
		public getBoundingBox(): { minPt: McGePoint3d; maxPt: McGePoint3d; ret: boolean } {
			const minX = Math.min(this.pt1.x, this.pt2.x);
			const minY = Math.min(this.pt1.y, this.pt2.y);
			const maxX = Math.max(this.pt1.x, this.pt2.x);
			const maxY = Math.max(this.pt1.y, this.pt2.y);

			return {
				minPt: new McGePoint3d(minX, minY, 0),
				maxPt: new McGePoint3d(maxX, maxY, 0),
				ret: true
			};
		}
	}

	async function MxTest_DrawCustomEntity() {
		let mxcad = MxCpp.getCurrentMxCAD();
		const getPoint = new MxCADUiPrPoint();
		getPoint.setMessage("\n指定一点:");
		let pt1 = (await getPoint.go());
		if (!pt1) return;

		getPoint.setBasePt(pt1);
		getPoint.setUseBasePt(true);

		getPoint.setMessage("\n指定二点:");
		let pt2 = (await getPoint.go());
		if (!pt2) return;

		let myline = new McDbTestLine();
		myline.setPoint1(pt1);
		myline.setPoint2(pt2);
		mxcad.drawEntity(myline);
	};

	// 注册自定义实体
	new McDbTestLine().rxInit();
 * ```
 */
export declare abstract class McDbCustomEntity extends McDbEntity {
	/**
	 * 构造函数。
	 * @param imp 内部实现对象。
	 */
	constructor(imp?: any);
	/**
	* 自定义实体注册
	* @example
	* ```ts
	* import { MxFun } from 'mxdraw
	* // MxCAD创建成功
	* MxFun.on("mxcadApplicationCreatedMxCADObject", (param) => {
	* // McDbTestLineCustomEntity 自定义实体
	*   new McDbTestLineCustomEntity().rxInit();// 自定义实体注册
	*   MxFun.addCommand("MxTest_DrawCustomEntity");// 注册绘制实体命令
	* })
	* ```
	*/
	rxInit(): void;
	/**
	 * 复制实体
	 */
	clone(): McDbObject | null;
	/** js 对像的数据与McDbCustomEntity::m_mapData的同步。 */
	syncData(toCpp?: boolean): boolean;
	/**
	 * @internal
	 * MxCAD辅助,内部使用
	 * ```
	 */
	tempRelationObject(): number;
	/**
	 * @internal
	 * MxCAD辅助,内部使用
	 * ```
	 */
	freeTempRelationObject(): void;
	protected assertWrite(autoUndo?: boolean): void;
	/**
	 * 移动自定义对象的夹点。
	 * @param _iIndex 夹点索引
	 * @param _dXOffset X轴偏移量
	 * @param _dYOffset Y轴偏移量
	 * @param _dZOffset Z轴偏移量
	 * @example
	 * ```ts
	   import { McDbCustomEntity, MxCADWorldDraw, McDbLine } from 'mxcad';
	   // 新创建 McDbTestLineCustomEntity 类继承 McDbCustomEntity
	   class McDbTestLineCustomEntity extends McDbCustomEntity {
			// 定义McDbTestLineCustomEntity内部的点对象 pt1、pt2
			private pt1: McGePoint3d = new McGePoint3d();
			private pt2: McGePoint3d = new McGePoint3d();
			// 移动自定义对象的夹点。
			public moveGripPointsAt(iIndex: number, dXOffset: number, dYOffset: number, dZOffset: number) {
				this.assertWrite();
				if (iIndex == 0) {
				this.pt1.x += dXOffset;
				this.pt1.y += dYOffset;
				this.pt1.z += dZOffset;
				}
				else if (iIndex == 1) {
				this.pt2.x += dXOffset;
				this.pt2.y += dYOffset;
				this.pt2.z += dZOffset;
				}
			};
		}
	 * ```
	 */
	moveGripPointsAt(_iIndex: number, _dXOffset: number, _dYOffset: number, _dZOffset: number): void;
	/**
	 * 获取自定义对象的夹点。
	 * @returns 夹点对象数组
	 */
	getGripPoints(): McGePoint3dArray;
	/**
	 * 获取自定义对象的夹点。
	 * @returns 夹点对象数组
	 */
	getGripEditBasePointsIndex(): number[];
	/**
	 * 获取自定义对象矩阵坐标变换
	 */
	transformBy(_mat: McGeMatrix3d): boolean;
	/**
	 * 新创建一个自定义对象 (默认调用该对象的构造函数来创建新的对象)
	 */
	abstract create(imp?: any): McDbCustomEntity;
	/**
	 * 获取自定义实体的类型名称。
	 * @returns 自定义实体的类型名称
	 */
	abstract getTypeName(): string;
	/**
	 * 获取自定义对象名称
	 */
	getName(): string;
	/**
	 * 从 DWG 文件中读取自定义实体的数据字段
	 */
	abstract dwgInFields(filter: IMcDbDwgFiler): boolean;
	/**
	 * 将自定义实体的数据字段写入到 DWG 文件中
	 */
	abstract dwgOutFields(filter: IMcDbDwgFiler): boolean;
	/**
	 * 绘制自定义实体
	 */
	abstract worldDraw(draw: MxCADWorldDraw): void;
	/**
	 * 得到对象的最小外包
	 */
	getBoundingBox(): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
		ret: boolean;
	};
}
export interface MarksStyleText {
	text: string;
	font?: string;
	fontSize?: number;
	bold?: boolean;
	italic?: boolean;
	underline?: boolean;
	strike?: boolean;
	style?: string;
	overline?: boolean;
	color?: number | number[];
	type?: string;
	/** 倾斜角度 */
	tiltAngle?: number;
	/**  追踪*/
	tracking?: number;
	/** 宽度因子 */
	widthFactor?: number;
	/** 文本位置: 'superscript' - 上标, 'subscript' - 下标，undefined - 正常 */
	textPosition?: "superscript" | "subscript";
	/** 垂直对齐方式: 'top' - 顶部对齐, 'bottom' - 底部对齐, 'middle' - 中间对齐 */
	verticalAlign?: "top" | "bottom" | "middle";
}
export type CustomText = MarksStyleText;
export interface BaseElement {
	type: string;
	children: Array<IMxEditorElement | CustomText>;
}
export interface ParagraphElement extends BaseElement {
	type: "paragraph";
	alignment?: "left" | "center" | "right" | "justify" | "distribute";
	lineHeightRatio?: number;
}
export type IMxEditorElement = BaseElement | ParagraphElement;
export type IMxEditorNode = IMxEditorElement | CustomText;
export interface IMxEditorPoint {
	path: number[];
	offset: number;
}
export type IMxEditorDescendant = IMxEditorNode | MarksStyleText;
declare enum SequenceType {
	/** 中文字符序列 */
	Chinese = "chinese",
	/** 连续字符序列（如英文单词、数字等） */
	Continuous = "continuous",
	/** 其他可断行字符（空格、标点等） */
	Breakable = "breakable",
	/** 行内元素 */
	Element = "element",
	/** 自定义文本节点*/
	TextNode = "textNode"
}
/**
 * 序列中的片段信息
 */
export interface SequenceFragment {
	/** 文本节点 */
	node: MarksStyleText | IMxEditorElement;
	/** 节点索引 */
	nodeIndex: number;
	/** 在节点中的起始位置 */
	startOffset: number;
	/** 在节点中的结束位置 */
	endOffset: number;
	/** 片段文本内容 */
	text: string;
}
/**
 * 表示文本中的一个序列
 * 一个序列可能跨越多个文本节点
 */
export interface TextSequence {
	/** 序列类型 */
	type: SequenceType;
	/** 序列包含的文本片段 */
	fragments: SequenceFragment[];
	/** 序列的完整文本 */
	text: string;
	/** 是否超出范围自动换行 */
	isAutoBreak?: boolean;
}
/**
 * 文本片段信息
 */
export interface TextFragment {
	/** 原始文本节点 */
	node: MarksStyleText | IMxEditorElement;
	/** 节点路径 [段落索引, 节点索引] */
	path: number[];
	/** 起始偏移 */
	startOffset: number;
	/** 结束偏移 */
	endOffset: number;
	/** 片段宽度 */
	width: number;
	height: number;
	index: number;
	/** 是否需要字符级别间距 */
	hasCharLevelSpacing?: boolean;
	/** 引用的序列，用于获取字符宽度 */
	sequence?: TextSequence;
	/** 字符间的额外间距，分布式布局结果 */
	extraCharSpacing?: number;
}
declare enum BreakType {
	None = "none",
	Overflow = "overflow",
	Word = "word",
	Forced = "forced"
}
export interface LineInfo {
	nodes: TextFragment[];
	height: number;
	width: number;
	breakInfo?: {
		isWrapped: boolean;
		breakType: BreakType;
	};
	horizontalOffset?: number;
	isEndLine?: boolean;
}
declare class MultilineTextConverter {
	/**
	 * 将McDbMText实体转换为McDbCustomEditorEntity
	 * @param mtext CAD多行文本实体
	 * @param options 转换选项
	 * @returns 自定义编辑器实体
	 */
	static fromMText(mtext: McDbMText): MxCADMText;
	/**
	 * 将McDbCustomEditorEntity转换为McDbMText
	 * @param customEntity 自定义编辑器实体
	 * @param options 转换选项
	 * @returns CAD多行文本实体
	 */
	static toMText(customEntity: MxCADMText, mtext?: McDbMText): (McDbEntity | McDbCustomEntity)[];
}
export interface CalculateData {
	width: number;
	height: number;
	lines?: LineInfo[];
	[x: string]: any;
}
export interface RenderData {
	position: McGePoint3d;
	index: number;
	alignmentWidth: number;
}
export interface RenderResult {
	[x: string]: any;
	entitys: (McDbEntity | McDbCustomEntity)[];
	position: McGePoint3d;
	width: number;
	height: number;
	lines: LineInfo[];
	lineHeightRatio?: number;
}
/**
 * 表示一个自定义文本元素基类，用于定义文本渲染的计算和绘制逻辑。
 * @description
 * MxCADBaseCustomElement 是所有自定义文本元素的抽象基类，它定义了元素类型、布局计算和绘制结果的契约。
 * 自定义文本元素可以通过 calculate 方法计算排版数据，通过 render 方法生成最终的实体列表并绘制到世界坐标中。
 * 使用方法:
 * 1. 继承 MxCADBaseCustomElement 并实现 type、calculate、render 三个抽象成员。
 * 2. 在 calculate 中基于传入的文本元素和编辑器元素计算宽高、行信息等布局数据。
 * 3. 在 render 中生成实体数组、位置、大小与行高，并返回 RenderResult。
 */
export declare abstract class MxCADBaseCustomElement {
	/** 类型 */
	abstract type: string;
	/** 计算布局数据 */
	abstract calculate(entity: MxCADMText, element: IMxEditorElement, index?: number): CalculateData;
	/** 渲染实体 */
	abstract render(entity: MxCADMText, draw: MxCADWorldDraw, element: IMxEditorElement, calculateData: CalculateData, renderData: RenderData): RenderResult;
}
export interface MxCADCustomTextCalculateData {
	width: number;
	height: number;
	[x: string]: any;
}
export interface CreateData {
	position: McGePoint3d;
}
/**
 * 表示自定义文本元素的基类，用于定义文本节点的布局计算和实体生成。
 * @description
 * MxCADBaseCustomText 是一个抽象基类，负责为自定义文本节点提供宽高计算和实体创建接口。
 * 继承此类的实现类可以根据文本节点内容计算尺寸，并生成对应的 McDbEntity 或 McDbCustomEntity 实体。
 * 使用方法:
 * 1. 继承 MxCADBaseCustomText 并实现 type、calculate、create 方法。
 * 2. 在 calculate 中根据文本节点计算宽度和高度等布局数据。
 * 3. 在 create 中根据计算结果和位置生成可绘制实体数组。
 */
export declare abstract class MxCADBaseCustomText {
	/** 类型 */
	abstract type: string;
	/** 计算布局数据 */
	abstract calculate(entity: MxCADMText, textNode: MarksStyleText): MxCADCustomTextCalculateData;
	/** 创建实体 */
	abstract create(entity: MxCADMText, textNode: MarksStyleText, calculateData: MxCADCustomTextCalculateData, renderData: CreateData): (McDbEntity | McDbCustomEntity)[];
}
declare class ElementTextManager {
	private elementMap;
	private textMap;
	/** 特殊字符映射表 (Unicode字符 -> CAD特殊字符) */
	private specialCharacterMap;
	constructor();
	/** 注册自定义元素 */
	registerElement(props: MxCADBaseCustomElement): void;
	registerTextNode(props: MxCADBaseCustomText): void;
	/** 注册特殊字符映射 (Unicode字符 -> CAD特殊字符) */
	registerSpecialCharacter(unicodeChar: string, cadSpecialChar: string): void;
	/** 遍历特殊字符映射表 */
	forEachSpecialCharacter(callback: (unicodeChar: string, cadSpecialChar: string) => void): void;
	getText(type: string): MxCADBaseCustomText | undefined;
	hasText(type: string): boolean;
	get(type: string): MxCADBaseCustomElement | undefined;
	has(type: string): boolean;
}
export type EventType = string | symbol;
export type PubSubEvent = Record<EventType, (...ages: any) => any>;
declare class PubSub<Events extends PubSubEvent = PubSubEvent> {
	events: {
		[x: EventType]: Events[keyof Events][];
	};
	constructor();
	/**
	 * 订阅
	 * @param event 事件名称
	 * @param callback 事件回调
	 */
	on<Key extends keyof Events>(event: Key, callback: Events[keyof Events]): void;
	/**
	 * 订阅一次
	 * @param event 事件名称
	 * @param callback 事件回调
	 */
	once<Key extends keyof Events>(event: Key, callback: Events[keyof Events]): void;
	/**
	 * 发布
	 * @param event 事件名称
	 * @param data 载荷
	 */
	emit<Key extends keyof Events>(event: Key | number, ...data: Parameters<Events[Key]>): void;
	/**
	 * 销毁事件
	 * @param event 事件名称
	 * @param callback 事件方法
	 */
	off<Key extends keyof Events>(event: Key, callback?: Events[keyof Events]): void;
}
declare function getActualRenderStartPosition(this: MxCADMTextImp, contentHeight?: number, contentWidth?: number): McGePoint3d;
declare function getLinePosition(this: MxCADMTextImp, paragraphIndex: number, lineIndex: number): {
	start: McGePoint3d;
	end: McGePoint3d;
	minPt: McGePoint3d;
	maxPt: McGePoint3d;
	height: number;
} | null;
declare class MxCADMTextImp extends PubSub<{
	"changed": () => void;
}> {
	position: McGePoint3d;
	maxWidth: number;
	maxHeight: number;
	textBaseHeight: number;
	data: IMxEditorDescendant[];
	isWordWrap: boolean;
	textAlignment: McDb.AttachmentPoint;
	actualHeight: number;
	actualWidth: number;
	mat: McGeMatrix3d;
	angle: number;
	lineHeightRatio: number;
	entityType: "custom" | "mtext";
	/** 强制不拆散多行文本(entityType === 'mtext' 时有效) */
	isIntegrityLockedMText: boolean;
	/** 文档中存在自定义文本或者元素 */
	get isCustomTextOrElement(): boolean;
	isEditState: boolean;
	__PARAGRAPH_INFOS__: (RenderResult & CalculateData)[];
	dwgInFields(filter: IMcDbDwgFiler): boolean;
	dwgOutFields(filter: IMcDbDwgFiler): boolean;
	/** 获取实际渲染起始位置 */
	getActualRenderStartPosition: typeof getActualRenderStartPosition;
	/**
	 * 获取夹点位置
	 * 返回三个夹点：
	 * 1. 位置点
	 * 2. 宽度控制点（position+maxWidth）
	 * 3. 高度控制点（position + maxWidth/2 + maxHeight）
	 */
	getGripPoints(): McGePoint3dArray;
	/**
	 * 移动夹点位置
	 * 根据不同夹点索引更新相应属性：
	 * 0 - 更新位置点
	 * 1 - 更新宽度
	 * 2 - 更新高度
	 */
	moveGripPointsAt(iIndex: number, dXOffset: number, dYOffset: number, dZOffset: number): void;
	/** 获取指定段落和行的位置信息 */
	getLinePosition: typeof getLinePosition;
	/**
	 * 获取指定段落的行信息
	 * @param this McDbCustomEditorEntity实例
	 * @param paragraphIndex 段落索引
	 * @returns 段落中的所有行信息
	 */
	getParagraphLines(paragraphIndex: number): LineInfo[];
	getParagrapInfo(paragraphIndex: number): RenderResult & CalculateData;
	/**
	 * 获取指定段落的行数
	 * @param this McDbCustomEditorEntity实例
	 * @param paragraphIndex 段落索引
	 * @returns 行数
	 */
	getLineCount(paragraphIndex: number): number;
	/** 获取文本节点高度 */
	getTextHeight: (node: MarksStyleText, baseHeight: number, ent: MxCADMText) => number;
	/** 设置数据 */
	setData(data: IMxEditorDescendant[]): void;
	/**
	 * 获取左上角点
	 * 直接使用pt1作为参照点，并返回经过矩阵变换后的世界坐标
	 */
	getTopLeftPt(): McGePoint3d;
	/**
	 * 获取指定行的水平偏移量
	 * @param paragraphIndex 段落索引
	 * @param lineIndex 行索引
	 * @returns 水平偏移量
	 */
	getLineHorizontalOffset(paragraphIndex: number, lineIndex: number): number;
	/**
	 * 获取总内容高度
	 * @returns 总内容高度
	 */
	getTotalContentHeight(): number;
	/** 设置实体类型 */
	setEntityType(type: "custom" | "mtext"): void;
	/** 获取节点Color颜色 */
	getColor: (node: MarksStyleText) => McCmColor | undefined;
}
declare function convertCadPointToSlatePoint(this: MxCADMText, point: McGePoint3d): {
	path: number[];
	offset: number;
} | null;
declare function convertSlatePointToCadPoint(this: MxCADMText, point: IMxEditorPoint): {
	point: McGePoint3d;
	lineIndex: number;
} | null;
/**
 * MxCAD 多行文本实体类，用于在 CAD 中渲染、编辑和管理富文本内容。
 *
 * @description
 * MxCADMText 是一种自定义多行文本实体，适用于在 MxCAD 场景中展示富文本、自动换行、行高控制、文本对齐和多段落排版。
 * 这个类能够完成：
 * - 创建和管理多行文本对象的数据与样式；
 * - 按指定宽度、行高、对齐方式进行排版；
 * - 支持角度、位置、最大宽高等属性的动态更新；
 * - 在 worldDraw 阶段将文本内容按元素递归渲染到 CAD 界面；
 * - 处理夹点编辑、坐标转换和自定义变换逻辑。
 *
 * 使用方式：
 * 1. 实例化 MxCADMText，并设置 data、position、maxWidth、lineHeightRatio 等属性；
 * 2. 在需要时调用 angle、textAlignment、isWordWrap 等属性更新渲染状态；
 * 3. 通过 worldDraw() 把文本内容绘制到当前图形环境；
 * 4. 调用 customizeTransformBy() 或 transformBy() 完成矩阵变换；
 * 5. 通过 MxCpp.mxcad.drawEntity() 将文本实体绘制到 CAD 界面。
 *
 * 总结：MxCADMText 是 MxCAD 场景中的富文本自定义实体，通常用于需要复杂多行排版、编辑交互和自定义渲染的文本场景。
 */
export declare class MxCADMText extends McDbCustomEntity {
	private impMText;
	getMTextImp(): MxCADMTextImp;
	/** 从McDbMText转换为MxCADMText */
	static fromMText: typeof MultilineTextConverter.fromMText;
	/** 从MxCADMText转换为McDbMText */
	static toMText: typeof MultilineTextConverter.toMText;
	static elementTextManager: ElementTextManager;
	constructor(imp?: any);
	get data(): IMxEditorDescendant[];
	set data(val: IMxEditorDescendant[]);
	get textBaseHeight(): number;
	set textBaseHeight(val: number);
	get angle(): number;
	set angle(angle: number);
	get position(): McGePoint3d;
	set position(val: McGePoint3d);
	get maxWidth(): number;
	set maxWidth(val: number);
	get maxHeight(): number;
	set maxHeight(val: number);
	get isWordWrap(): boolean;
	/** 设置自动换行 */
	set isWordWrap(value: boolean);
	get lineHeightRatio(): number;
	set lineHeightRatio(ratio: number);
	get textAlignment(): McDb.AttachmentPoint;
	set textAlignment(alignment: McDb.AttachmentPoint);
	create(imp: any): MxCADMText;
	getTypeName(): string;
	getName(): string;
	dwgInFields(filter: IMcDbDwgFiler): boolean;
	dwgOutFields(filter: IMcDbDwgFiler): boolean;
	moveGripPointsAt(iIndex: number, dXOffset: number, dYOffset: number, dZOffset: number): void;
	getGripPoints(): McGePoint3dArray;
	worldDraw(draw: MxCADWorldDraw): void;
	/** CAD坐标转换为Slate的Point位置 */
	convertCadPointToSlatePoint: typeof convertCadPointToSlatePoint;
	/** Slate的Point位置转换为CAD坐标 */
	convertSlatePointToCadPoint: typeof convertSlatePointToCadPoint;
	/** 自定义变换矩阵函数 */
	customizeTransformBy(mat: McGeMatrix3d): boolean;
	transformBy(_met: McGeMatrix3d): boolean;
	getBoundingBox(): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
		ret: boolean;
	};
}
/**
 * 表格渲染方向枚举
 */
export declare enum TableRenderDirection {
	/** 向右下方向渲染（默认） */
	BottomRight = "BottomRight",
	/** 向左下方向渲染 */
	BottomLeft = "BottomLeft",
	/** 向右上方向渲染 */
	TopRight = "TopRight",
	/** 向左上方向渲染 */
	TopLeft = "TopLeft"
}
/**
 * 合并单元格信息接口
 */
export interface IMergeCellInfo {
	row: number;
	col: number;
	rowspan: number;
	colspan: number;
}
export interface ICellStyleInfo {
	data: any[][];
	mergeCells?: IMergeCellInfo[];
	colWidths?: IColumnWidth[];
	rowHeights?: IRowHeight[];
	cellStyles?: CellStyleInfo;
}
export interface CellStyleInfo {
	[key: string]: ICellStyle;
}
/**
 * 行高信息接口
 */
export interface IRowHeight {
	row: number;
	height: number;
}
/**
 * 列宽信息接口
 */
export interface IColumnWidth {
	col: number;
	width: number;
}
/**
 * 表格数据接口
 */
export interface ITableData {
	data: any[][];
	mergeCells?: IMergeCellInfo[];
	styles?: any;
	rowHeights?: IRowHeight[];
	colWidths?: IColumnWidth[];
	rowCount: number;
	cols: number;
}
/**
 * 表格样式接口
 */
export interface ITableStyle {
	name: string;
	textHeight: number;
	outerBorderColor?: number;
	borderColor: number;
	textColor: number;
	backgroundColor?: number | null;
	/**
	 * 文本对齐方式
	 * - 'left': 左对齐
	 * - 'center': 居中对齐
	 * - 'right': 右对齐
	 */
	textAlignment?: "left" | "center" | "right";
	/**
	 * 文本垂直对齐方式
	 * - 'top': 顶部对齐
	 * - 'middle': 垂直居中
	 * - 'bottom': 底部对齐
	 */
	textVerticalAlignment?: "top" | "middle" | "bottom";
	/**
	 * 文本样式名称
	 * 指定要使用的文字样式名称
	 */
	textStyle?: string;
	/**
	 * 边框线宽
	 * 表格边框线宽，单位为毫米
	 */
	borderLineWeight?: number;
	/**
	 * 边框线型
	 * 表格边框线型名称，如"Continuous", "Dashed", "Dotted"等
	 */
	borderLineType?: string;
}
export type ITableStyleInfo = Partial<Omit<ITableStyle, "name">>;
/**
 * 表格尺寸接口
 */
export interface ITableDimensions {
	width: number;
	height: number;
}
/**
 * 表格位置接口
 */
export interface ITablePosition {
	x: number;
	y: number;
	z: number;
}
/**
 * 单元格样式接口
 */
export interface ICellStyle {
	backgroundColor?: number | null;
	textColor?: number | null;
	alignment?: "left" | "center" | "right";
	verticalAlignment?: "top" | "middle" | "bottom";
	/**
	 * 文本样式名称
	 * 指定要使用的文字样式名称
	 */
	textStyle?: string;
	/**
	 * 文本角度
	 * 文本旋转角度，以度为单位(0-360)
	 */
	textAngle?: number;
	/**
	 * 边框线宽
	 * 单元格边框线宽，单位为毫米
	 */
	borderLineWeight?: number;
	/**
	 * 边框线型
	 * 单元格边框线型名称，如"Continuous", "Dashed", "Dotted"等
	 */
	borderLineType?: string;
}
/**
 * XLSX表格数据接口
 */
export interface IXlsxTableData {
	data: any[][];
	mergeCells: IMergeCellInfo[];
	styles: any;
	rowHeights: IRowHeight[];
	colWidths: IColumnWidth[];
}
/**
 * XLSX 表格实体类，用于在 CAD 中展示和管理表格型数据内容。
 *
 * @description
 * McDbXlsxTable 是一个自定义表格实体，适合把 Excel/XLSX 数据结构映射到 CAD 图形对象中进行展示。
 * 这个类可以完成：
 * - 解析和保存表格原始 XLSX 数据；
 * - 设置行高、列宽、样式、位置和渲染方向；
 * - 处理单元格合并、样式和文本尺寸计算；
 * - 在 worldDraw 阶段把表格渲染到绘图环境中；
 * - 适配 CAD 中的交互编辑和对象变换逻辑。
 *
 * 使用方式：
 * 1. 创建 McDbXlsxTable 实例；
 * 2. 设置 position、rowHeight、colWidth、renderDirection 等核心属性；
 * 3. 通过 xlsxData 传入 Base64 表格数据，或直接设置表格内容与样式；
 * 4. 调用 worldDraw() 或绘制流程把表格显示在 CAD 中；
 * 5. 如需编辑，可同步更新样式、单元格数据和位置后重绘。
 *
 * 总结：McDbXlsxTable 是 MxCAD 表格展示的自定义实体，适合把结构化表格内容以可视化方式嵌入到工程图中。
 *
 * @example
 * ```ts
	import { MxCpp, McDbXlsxTable, MxCADUiPrPoint } from "mxcad";

	//绘制表格
	async function Mx_drawTable() {
	const table: McDbXlsxTable = new McDbXlsxTable();

	// 设置基本属性
	table.colWidth = 5; // 默认列宽
	table.rowHeight = 5; // 默认行高
	table.styleName = "STANDARD"; // 设置表格样式
	// 方法1：从数组创建表格
	const data = [
		["标题1", "标题2", "标题3", "标题4"],
		["数据1", "数据2", "数据3", "数据4"],
		["数据5", "数据6", "数据7", "数据8"],
		[
		"数据9",
		"数据10",
		"数据11",
		[
			{
			type: "paragraph",
			children: [
				{
				text: "ssss",
				},
			],
			},
			{
			type: "paragraph",
			children: [
				{
				text: "666",
				},
			],
			},
		],
		],
	];
	table.setFromArray(data);

	// 合并单元格
	table.setMergeCells([
		{
		row: 0,
		col: 0,
		rowspan: 1,
		colspan: 4, // 合并第一行的所有单元格作为标题
		},
	]);

	// 设置第一行的值为标题
	table.setCellValue(0, 0, "表格标题");

	// 设置表格位置
	const mxcad = MxCpp.getCurrentMxCAD();
	const getPoint = new MxCADUiPrPoint();
	getPoint.setMessage("\n指定表格插入点");
	const pt = await getPoint.go();
	table.position = pt;

	// 绘制表格
	mxcad.drawEntity(table);
	}
 * ```
 */
export declare class McDbXlsxTable extends McDbCustomEntity {
	matrix: McGeMatrix3d;
	private _rowHeight;
	/**
	 * 表格整体行高
	 * */
	get rowHeight(): number;
	set rowHeight(val: number);
	/**  表格行数*/
	get rowCount(): number;
	/**  表格列数*/
	get colCount(): number;
	private _colWidth;
	/**
	 * 表格整体列宽
	 * */
	get colWidth(): number;
	set colWidth(val: number);
	private _style;
	get style(): Partial<Omit<ITableStyle, "name">> | null;
	/** 设置该表格样式 */
	setStyle(style: ITableStyleInfo): void;
	private _position;
	/** 表格位置和尺寸 - 渲染必需 */
	get position(): McGePoint3d;
	set position(val: McGePoint3d);
	private _renderDirection;
	/** 表格渲染方向 */
	get renderDirection(): TableRenderDirection;
	set renderDirection(val: TableRenderDirection);
	private _styleName;
	/** 表格样式名称 */
	get styleName(): string;
	set styleName(val: string);
	private _colWidths;
	private _rowHeights;
	private _xlsxData;
	get xlsxData(): string;
	set xlsxData(data: string);
	private _mergeCells;
	private _selectedCells;
	private _cellTextDimensions;
	private _cellStyles;
	constructor(imp?: any);
	create(imp: any): McDbXlsxTable;
	getTypeName(): string;
	/** 获取单元格的样式 */
	getCellStyles(): CellStyleInfo;
	private getTableData;
	private getDefaultStyle;
	getBoundingBox(): {
		minPt: McGePoint3d;
		maxPt: McGePoint3d;
		ret: boolean;
	};
	/**
	 * 处理合并单元格数据，填充空值
	 * 根据合并单元格信息，将合并区域内的空单元格填充为合并区域左上角的值
	 */
	private processMergedCellData;
	dwgInFields(filter: IMcDbDwgFiler): boolean;
	dwgOutFields(filter: IMcDbDwgFiler): boolean;
	/** 计算表格尺寸 */
	calculateTableDimensions(): {
		width: number;
		height: number;
	};
	/**
	 * 获取选中单元格的范围
	 * @returns 包含选中范围的最小和最大行列索引
	 */
	getSelectionRange(): {
		minRow: number;
		minCol: number;
		maxRow: number;
		maxCol: number;
	} | null;
	/**
	 * 设置当前选中的单元格
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 */
	setSelectedCell(row: number, col: number): void;
	/**
	 * 添加一个单元格到选中集合
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 */
	addSelectedCell(row: number, col: number): void;
	/**
	 * 设置多个选中的单元格
	 * @param cells 单元格位置数组 [{row, col}, ...]
	 */
	setSelectedCells(cells: {
		row: number;
		col: number;
	}[]): void;
	/**
	 * 清除当前选中的单元格
	 */
	clearSelectedCell(): void;
	/**
	 * 获取当前选中的单元格
	 * @returns 第一个选中的单元格，如果没有选中则返回null
	 */
	getSelectedCell(): {
		row: number;
		col: number;
	} | null;
	/**
	 * 获取所有选中的单元格
	 * @returns 所有选中的单元格数组
	 */
	getSelectedCells(): {
		row: number;
		col: number;
	}[];
	/**
	 * 检查指定单元格是否被选中
	 * @param row 行索引
	 * @param col 列索引
	 * @returns 是否被选中
	 */
	isCellSelected(row: number, col: number): boolean;
	/**
	 * 获取选中单元格的数量
	 * @returns 选中的单元格数量
	 */
	getSelectedCellCount(): number;
	worldDraw(draw: MxCADWorldDraw): void;
	setFromWorkbook(processedData: ICellStyleInfo): void;
	setFromJson(jsonArray: any[]): void;
	setFromArray(data: any[][]): void;
	/**
	 * 设置合并单元格信息
	 */
	setMergeCells(mergeCells: IMergeCellInfo[]): void;
	/**
	 * 获取合并单元格信息
	 */
	getMergeCells(): IMergeCellInfo[];
	/**
	 * 设置指定列的宽度
	 * @param col 列索引 (0-based)
	 * @param width 列宽度（单位与style.colWidth一致）
	 */
	setColumnWidth(col: number, width: number): void;
	/**
	 * 获取指定列的宽度
	 * @param col 列索引 (0-based)
	 * @returns 列宽度，如果未设置则返回默认列宽
	 */
	getColumnWidth(col: number): number;
	/**
	 * 获取所有列宽设置
	 */
	getAllColumnWidths(): IColumnWidth[];
	/**
	 * 重置指定列的宽度为默认值
	 * @param col 列索引 (0-based)
	 */
	resetColumnWidth(col: number): void;
	/**
	 * 设置指定行的高度
	 * @param row 行索引 (0-based)
	 * @param height 行高度（单位与style.rowHeight一致）
	 */
	setRowHeight(row: number, height: number): void;
	/**
	 * 获取指定行的高度
	 * @param row 行索引 (0-based)
	 * @returns 行高度，如果未设置则返回默认行高
	 */
	getRowHeight(row: number): number;
	/**
	 * 获取所有行高设置
	 */
	getAllRowHeights(): IRowHeight[];
	/**
	 * 重置指定行的高度为默认值
	 * @param row 行索引 (0-based)
	 */
	resetRowHeight(row: number): void;
	/**
	 * 获取指定单元格的值
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格值
	 */
	getCellValue(row: number, col: number): any;
	/**
	 * 设置指定单元格的值
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param value 单元格值（Slate格式或普通文本）
	 */
	setCellValue(row: number, col: number, value: any): void;
	/**
	 * 获取单元格的纯文本值（如果是Slate格式则提取文本）
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格的纯文本值
	 */
	getCellTextValue(row: number, col: number): string;
	/**
	 * 获取指定单元格（考虑合并）在世界坐标系下的四个角点
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns McGePoint3d[] 顺序： [左上, 右上, 右下, 左下]
	 */
	getCellWorldCorners(row: number, col: number): McGePoint3d[] | null;
	/**
	 * 获取指定单元格的几何范围
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格的几何范围 { min: McGePoint3d, max: McGePoint3d } 或 null (当单元格不存在时)
	 */
	getCellGeometry(row: number, col: number): {
		min: McGePoint3d;
		max: McGePoint3d;
	} | null;
	/**
   * 将CAD坐标点转换为表格中的单元格位置
   * @param point CAD空间中的三维点
   * @returns 单元格位置 {row, col} 或 null (当点不在表格内时)
   */
	getCellAtPoint(point: McGePoint3d): {
		row: number;
		col: number;
	} | null;
	/**
	 * 获取指定单元格的A1格式引用
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns A1格式的单元格引用 (例如 "A1", "B2")
	 */
	getCellReference(row: number, col: number): string;
	/**
	 * 从A1格式引用获取单元格索引
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @returns 单元格索引 {row, col} 或 null (当引用无效时)
	 */
	getCellFromReference(cellRef: string): {
		row: number;
		col: number;
	} | null;
	/**
	 * 设置单元格背景颜色
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param color 背景颜色值
	 * - 支持真彩色：0xRRGGBB，如 0x000000 黑色（RR是红色值，GG是绿色值，BB是蓝色值）
	 * - 支持颜色索引：0-255
	 * - 支持ColorMethod.kByLayer(1)表示随层
	 * - 支持ColorMethod.kByBlock(2)表示随块
	 * - 传入null可移除背景颜色
	 */
	setCellBackgroundColor(row: number, col: number, color: number | null | undefined): void;
	/**
	 * 获取单元格背景颜色
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格背景颜色，如果未设置则返回null
	 */
	getCellBackgroundColor(row: number, col: number): number | null | undefined;
	/**
	 * 通过A1引用格式设置单元格背景颜色
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param color 背景颜色值，null表示删除背景色
	 * @returns 是否设置成功
	 */
	setCellBackgroundColorByRef(cellRef: string, color: number | null | undefined): boolean;
	/**
	 * 批量设置单元格背景颜色
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param color 背景颜色值，null表示删除背景色
	 */
	setBatchCellBackgroundColor(cells: (string | {
		row: number;
		col: number;
	})[], color: number | null | undefined): void;
	/**
	 * 设置单元格文本颜色
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param color 文本颜色值
	 * - 支持真彩色：0xRRGGBB，如 0x000000 黑色（RR是红色值，GG是绿色值，BB是蓝色值）
	 * - 支持颜色索引：0-255
	 * - 支持ColorMethod.kByLayer(1)表示随层
	 * - 支持ColorMethod.kByBlock(2)表示随块
	 * - 传入null可移除文本颜色
	 */
	setCellTextColor(row: number, col: number, color: number | null | undefined): void;
	/**
	 * 获取单元格文本颜色
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格文本颜色，如果未设置则返回null
	 */
	getCellTextColor(row: number, col: number): number | null | undefined;
	/**
	 * 通过A1引用格式设置单元格文本颜色
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param color 文本颜色值，null表示删除文本颜色
	 * @returns 是否设置成功
	 */
	setCellTextColorByRef(cellRef: string, color: number | null | undefined): boolean;
	/**
	 * 批量设置单元格文本颜色
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param color 文本颜色值，null表示删除文本颜色
	 */
	setBatchCellTextColor(cells: (string | {
		row: number;
		col: number;
	})[], color: number | null | undefined): void;
	/**
	 * 设置单元格水平对齐方式
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param alignment 水平对齐方式
	 */
	setCellAlignment(row: number, col: number, alignment: "left" | "center" | "right"): void;
	/**
	 * 获取单元格水平对齐方式
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 水平对齐方式，如果未设置则返回'left'
	 */
	getCellAlignment(row: number, col: number): "left" | "center" | "right" | undefined;
	/**
	 * 通过A1引用格式设置单元格水平对齐方式
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param alignment 水平对齐方式
	 * @returns 是否设置成功
	 */
	setCellAlignmentByRef(cellRef: string, alignment: "left" | "center" | "right"): boolean;
	/**
	 * 批量设置单元格水平对齐方式
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param alignment 水平对齐方式
	 */
	setBatchCellAlignment(cells: (string | {
		row: number;
		col: number;
	})[], alignment: "left" | "center" | "right"): void;
	/**
	 * 设置单元格垂直对齐方式
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param verticalAlignment 垂直对齐方式
	 */
	setCellVerticalAlignment(row: number, col: number, verticalAlignment: "top" | "middle" | "bottom"): void;
	/**
	 * 获取单元格垂直对齐方式
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 垂直对齐方式，如果未设置则返回'top'
	 */
	getCellVerticalAlignment(row: number, col: number): "top" | "middle" | "bottom" | undefined;
	/**
	 * 通过A1引用格式设置单元格垂直对齐方式
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param verticalAlignment 垂直对齐方式
	 * @returns 是否设置成功
	 */
	setCellVerticalAlignmentByRef(cellRef: string, verticalAlignment: "top" | "middle" | "bottom"): boolean;
	/**
	 * 批量设置单元格垂直对齐方式
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param verticalAlignment 垂直对齐方式
	 */
	setBatchCellVerticalAlignment(cells: (string | {
		row: number;
		col: number;
	})[], verticalAlignment: "top" | "middle" | "bottom"): void;
	getGripPoints(): McGePoint3dArray;
	moveGripPointsAt(iIndex: number, dXOffset: number, dYOffset: number, dZOffset: number): void;
	transformBy(_mat: McGeMatrix3d): boolean;
	/**
	 * 设置单元格文本样式
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param textStyle 文本样式名称
	 */
	setCellTextStyle(row: number, col: number, textStyle: string): void;
	/**
	 * 获取单元格文本样式
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格文本样式，如果未设置则返回undefined
	 */
	getCellTextStyle(row: number, col: number): string | undefined;
	/**
	 * 通过A1引用格式设置单元格文本样式
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param textStyle 文本样式名称
	 * @returns 是否设置成功
	 */
	setCellTextStyleByRef(cellRef: string, textStyle: string): boolean;
	/**
	 * 批量设置单元格文本样式
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param textStyle 文本样式名称
	 */
	setBatchCellTextStyle(cells: (string | {
		row: number;
		col: number;
	})[], textStyle: string): void;
	/**
	 * 设置单元格文本角度
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param textAngle 文本角度(0-360度)
	 */
	setCellTextAngle(row: number, col: number, textAngle: number): void;
	/**
	 * 获取单元格文本角度
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格文本角度，如果未设置则返回undefined
	 */
	getCellTextAngle(row: number, col: number): number | undefined;
	/**
	 * 通过A1引用格式设置单元格文本角度
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param textAngle 文本角度(0-360度)
	 * @returns 是否设置成功
	 */
	setCellTextAngleByRef(cellRef: string, textAngle: number): boolean;
	/**
	 * 批量设置单元格文本角度
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param textAngle 文本角度(0-360度)
	 */
	setBatchCellTextAngle(cells: (string | {
		row: number;
		col: number;
	})[], textAngle: number): void;
	/**
	 * 设置单元格边框线宽
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param lineWeight 边框线宽(毫米)
	 */
	setCellBorderLineWeight(row: number, col: number, lineWeight: number): void;
	/**
	 * 获取单元格边框线宽
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格边框线宽，如果未设置则返回undefined
	 */
	getCellBorderLineWeight(row: number, col: number): number | undefined;
	/**
	 * 通过A1引用格式设置单元格边框线宽
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param lineWeight 边框线宽(毫米)
	 * @returns 是否设置成功
	 */
	setCellBorderLineWeightByRef(cellRef: string, lineWeight: number): boolean;
	/**
	 * 批量设置单元格边框线宽
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param lineWeight 边框线宽(毫米)
	 */
	setBatchCellBorderLineWeight(cells: (string | {
		row: number;
		col: number;
	})[], lineWeight: number): void;
	/**
	 * 设置单元格边框线型
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @param lineType 边框线型(如 "Continuous", "Dashed", "Dotted"等)
	 */
	setCellBorderLineType(row: number, col: number, lineType: string): void;
	/**
	 * 获取单元格边框线型
	 * @param row 行索引 (0-based)
	 * @param col 列索引 (0-based)
	 * @returns 单元格边框线型，如果未设置则返回undefined
	 */
	getCellBorderLineType(row: number, col: number): string | undefined;
	/**
	 * 通过A1引用格式设置单元格边框线型
	 * @param cellRef A1格式的单元格引用 (例如 "A1", "B2")
	 * @param lineType 边框线型(如 "Continuous", "Dashed", "Dotted"等)
	 * @returns 是否设置成功
	 */
	setCellBorderLineTypeByRef(cellRef: string, lineType: string): boolean;
	/**
	 * 批量设置单元格边框线型
	 * @param cells 单元格位置数组 { row, col } 或 A1引用字符串数组
	 * @param lineType 边框线型(如 "Continuous", "Dashed", "Dotted"等)
	 */
	setBatchCellBorderLineType(cells: (string | {
		row: number;
		col: number;
	})[], lineType: string): void;
	/**
	 * 检查是否选中了合并的单元格
	 */
	isMergedCellSelected(): boolean;
	/**
	 * 检查是否选中了未合并的单元格
	 */
	hasUnmergedCellsSelected(): boolean;
	private updateMergeCellsAfterRowInsert;
	/**
	* 更新选中单元格并允许外部回调
	* @param cells 要选中的单元格
	* @param onSelectionChange 可选的选择变更回调
	*/
	private updateSelectedCells;
	/**
	* 在指定位置插入行
	* @param position 插入位置，'above' 为上方插入，'below' 为下方插入
	* @param onSelectionChange 可选的选择变更回调
	*/
	insertRow(position: "above" | "below", onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	private updateMergeCellsAfterRowDelete;
	/**
	 * 删除选中的行
	 * @param onSelectionChange 可选的选择变更回调
	 */
	deleteRow(onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	private updateMergeCellsAfterColumnInsert;
	/**
	 * 在指定位置插入列
	 * @param position 插入位置，'left' 为左侧插入，'right' 为右侧插入
	 * @param onSelectionChange 可选的选择变更回调
	 */
	insertColumn(position: "left" | "right", onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/** 更新合并单元格信息（删除列后） */
	private updateMergeCellsAfterColumnDelete;
	/**
	 * 删除选中的列
	 * @param onSelectionChange 可选的选择变更回调
	 */
	deleteColumn(onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/**
	 * 合并选中的单元格
	 * @param onSelectionChange 可选的选择变更回调
	 */
	mergeCells(onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/**
	  * 取消合并选中的单元格
	  * @param onSelectionChange 可选的选择变更回调
	  */
	unMergeCells(onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/**
	   * 设置选中单元格的水平对齐方式
	   * @param alignment 对齐方式
	   * @param onSelectionChange 可选的选择变更回调
	   */
	setAlignment(alignment: "left" | "center" | "right", onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/**
	* 设置选中单元格的垂直对齐方式
	* @param alignment 垂直对齐方式
	* @param onSelectionChange 可选的选择变更回调
	*/
	setVerticalAlignment(alignment: "top" | "middle" | "bottom", onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/**
	 * 设置选中单元格的背景颜色
	 * @param color 颜色值
	 * @param onSelectionChange 可选的选择变更回调
	 */
	setSelectCellBackgroundColor(color: number | null | undefined, onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/**
	 * 设置选中单元格的文本颜色
	 * @param color 颜色值
	 * @param onSelectionChange 可选的选择变更回调
	 */
	setSelectCellTextColor(color: number | null | undefined, onSelectionChange?: (cells: {
		row: number;
		col: number;
	}[]) => void): void;
	/**
	 * 获取选中单元格的背景颜色
	 */
	getSelectCellBackgroundColor(): number | null | undefined;
	/**
	 * 获取选中单元格的文本颜色
	 */
	getSelectCellTextColor(): number | null | undefined;
}
export interface MLStyleElement {
	offset: number;
	color: number;
	lineType: string;
}
export interface MLStyle {
	name: string;
	description: string;
	elements: MLStyleElement[];
	startCaps: {
		line: boolean;
		outerArc: boolean;
		innerArc: boolean;
		angle: number;
	};
	endCaps: {
		line: boolean;
		outerArc: boolean;
		innerArc: boolean;
		angle: number;
	};
	fill: {
		enabled: boolean;
		color: number;
	};
	displayJoints: boolean;
}
/**  多线对齐方式 */
export declare enum MLineJustificationType {
	No = -1,
	Top = 0,
	Middle = 1,
	Bottom = 2
}
/**
 * 线段关联数据的点对类型
 */
export type SegmentPointPair = [
	McGePoint3d,
	McGePoint3d
];
/**
 * 线段关联数据结构类型
 */
export interface SegmentRelationsData {
	[segmentIndex: number]: {
		[relatedSegmentIndex: number]: SegmentPointPair[];
	};
}
/**  点选获取线段关联数据结构 */
export interface PointSegmentRelation {
	/** 线段索引 */
	segmentIndex: number;
	/** 偏移元素索引 */
	elementIndex: number;
	/** 在线段上的精确点 */
	clickPoint: McGePoint3d;
	/** 所有偏移线的坐标点（按特定顺序排列 [最大偏移线，最小偏移线, 次大偏移线，次小偏移线, ...]） */
	allOffsetLines: McGePoint3d[][];
}
/**
 * MLine 多线实体类，用于在 CAD 中创建和编辑具有多条中心线或并排线效果的多线对象。
 *
 * @description
 * McDbMLine 是一种多线自定义实体，适用于绘制具有多重平行线、偏移样式、端点处理和填充效果的复杂线对象。
 * 这个类能够完成：
 * - 定义多线顶点与样式信息；
 * - 根据样式元素和偏移量生成多条并行线；
 * - 处理闭合、多段线、端点和连接关系；
 * - 在 worldDraw 阶段按照样式渲染多线，可用于道路、边界、中心线等图元；
 * - 支持关联线段数据、夹点编辑和几何变换。
 *
 * 使用方式：
 * 1. 创建 McDbMLine 实例，并设置 vertices、styleName、scale 等属性；
 * 2. 通过 setSegmentRelation / getSegmentRelation 管理线段关联数据；
 * 3. 调用 moveGripPointsAt() 或 getGripPoints() 进行交互编辑；
 * 4. 在渲染时通过 worldDraw() 根据样式和偏移生成多线效果；
 * 5. 最终调用 MxCpp.mxcad.drawEntity(mline) 将多线实体绘制到 CAD 界面。
 *
 * 总结：McDbMLine 是 mxcad 中的多线实体类，适合表示带有多重并行线样式的复杂线型对象，常用于道路、边界、中心线和装饰线的建模场景。
 *
 * @example
 * ```ts
 * import { McDbMLine, McGePoint3d, MxCpp } from "mxcad";
 *
 * const mline = new McDbMLine();
 * mline.styleName = "STANDARD";
 * mline.scale = 10;
 * mline.isClosed = false;
 * mline.vertices = [
 *   new McGePoint3d(0, 0, 0),
 *   new McGePoint3d(100, 0, 0),
 *   new McGePoint3d(150, 50, 0)
 * ];
 * MxCpp.mxcad.drawEntity(mline);
 */
export declare class McDbMLine extends McDbCustomEntity {
	private vertices;
	private styleName;
	private justification;
	private scale;
	private isClosed;
	private currentStyle;
	private segmentRelations;
	/**
	 * 设置线段关联数据
	 * @param segmentIndex 当前多线的线段索引
	 * @param relatedSegmentIndex 相关联多线的线段索引
	 * @param pointPairs 点对数组 [McGePoint3d, McGePoint3d][]
	 */
	setSegmentRelation(segmentIndex: number, relatedSegmentIndex: number, pointPairs: SegmentPointPair[]): void;
	/**
	 * 获取线段关联数据
	 * @param segmentIndex 当前多线的线段索引
	 * @param relatedSegmentIndex 相关联多线的线段索引（可选）
	 * @returns 如果提供了relatedSegmentIndex，返回对应的点对数组；否则返回所有关联数据
	 */
	getSegmentRelation(segmentIndex: number, relatedSegmentIndex?: number): SegmentPointPair[] | {
		[relatedSegmentIndex: number]: SegmentPointPair[];
	} | null;
	/**
	 * 获取所有线段关联数据
	 * @returns 完整的线段关联数据结构
	 */
	getAllSegmentRelations(): SegmentRelationsData;
	/**
	 * 设置所有线段关联数据
	 * @param data 完整的线段关联数据结构
	 */
	setAllSegmentRelations(data: SegmentRelationsData): void;
	/**
	 * 合并指定区域（从startPt到endPt）的关联数据
	 */
	mergeSegmentRelation(segmentIndex: number, relatedSegmentIndex: number, startPt: McGePoint3d, endPt: McGePoint3d): void;
	/**
	 * 清除指定线段的关联数据
	 * @param segmentIndex 要清除的线段索引
	 * @param relatedSegmentIndex 要清除的关联线段索引（可选，如果不提供则清除整个segmentIndex的数据）
	 */
	clearSegmentRelation(segmentIndex: number, relatedSegmentIndex?: number): void;
	private get elementOffsets();
	constructor(imp?: any);
	/**
	 * 创建实体的工厂方法
	 */
	create(imp: any): McDbMLine;
	/**
	 * 获取实体类型名称
	 */
	getTypeName(): string;
	/**
	 * 从数据文件读取实体数据
	 */
	dwgInFields(filter: IMcDbDwgFiler): boolean;
	/**
	 * 将实体数据写入到数据文件
	 */
	dwgOutFields(filter: IMcDbDwgFiler): boolean;
	/**
	 * 移动指定索引的控制点
	 */
	moveGripPointsAt(index: number, deltaX: number, deltaY: number, deltaZ: number): void;
	/**
	 * 处理移动控制点后的线段关联数据
	 * @param movedIndex 被移动的控制点索引
	 * @param originalPoint 移动前的原始点位置
	 */
	private handleSegmentRelationsAfterMove;
	/**
	 * 获取实体的控制点
	 */
	getGripPoints(): McGePoint3dArray;
	/**
	 * 绘制实体（统一调度，参数传递点集）
	 */
	worldDraw(draw: MxCADWorldDraw): void;
	/**
	 * 根据点获取线段索引
	 * @param point 选择点坐标
	 * @returns 找到的线段信息，包括线段索引、偏移线段索引及点击位置
	 */
	getSegmentByPoint(point: McGePoint3d): PointSegmentRelation | null;
	/**
	 * 根据索引获取线段数据
	 * @param segmentIndex 线段索引
	 * @returns 找到的线段信息，包括线段索引、偏移线段索引及相关数据
	 */
	getSegmentByIndex(segmentIndex: number): PointSegmentRelation | null;
	/**
	 * 计算指定偏移量下的多线偏移点（线段偏移+交点法）
	 */
	private getOffsetPolylinePoints;
	/**
	 * 根据对齐方式计算实际偏移值
	 * @param offset 原始偏移值
	 * @returns 根据对齐方式调整后的实际偏移值
	 */
	private calculateAlignedOffset;
	/**
	 * 绘制多线的每条线（参数传递点集）
	 */
	private drawMlines;
	/**
	 * 绘制指定偏移量的线（直接用已算好的点集）
	 */
	private drawOffsetLine;
	/**
	 * 绘制填充（参数传递点集）
	 */
	private drawFill;
	/**
	 * 绘制端点
	 */
	private drawCaps;
	/**
	 * 绘制端点弧线
	 */
	private drawCapArc;
	/**
	 * 获取默认样式
	 */
	private getDefaultStyle;
	/**
	 * 设置样式名称
	 */
	setStyleName(name: string): void;
	/**
	 * 获取样式名称
	 */
	getStyleName(): string;
	/**
	 * 设置对齐方式
	 */
	setJustification(justification: number): void;
	/**
	 * 获取对齐方式
	 */
	getJustification(): number;
	/**
	 * 设置比例
	 */
	setScale(scale: number): void;
	/**
	 * 获取比例
	 */
	getScale(): number;
	/**
	 * 添加顶点
	 */
	addVertex(point: McGePoint3d): void;
	/**
	 * 在指定位置插入顶点
	 * @param index 要插入的位置索引
	 * @param point 要插入的点
	 * @returns 是否插入成功
	 */
	insertVertexAt(index: number, point: McGePoint3d): boolean;
	getVertices(): McGePoint3d[];
	/**
	 * 获取顶点数量
	 */
	getVertexCount(): number;
	/**
	 * 获取顶点
	 */
	getVertexAt(index: number): McGePoint3d | null;
	/**
	 * 设置顶点
	 */
	setVertexAt(index: number, point: McGePoint3d): void;
	/**
	 * 移除顶点
	 */
	removeVertexAt(index: number): void;
	/**
	 * 清除所有顶点
	 */
	clearVertices(): void;
	/**
	 * 绘制拐点连接线
	 * 在每个转角处绘制从中心点到各条线拐点的连接线
	 */
	private drawJoints;
	/**
	 * 设置闭合状态
	 */
	setIsClosed(isClosed: boolean): void;
	/**
	 * 获取闭合状态
	 */
	getIsClosed(): boolean;
}
export declare let MxCpp: MxCppType;
/**
 * 异步加载 MxCAD assembly，并在加载完成后执行回调函数
 * @param call 回调函数，在加载完成后执行
 * @param locateFile 函数用于确定 wasm 文件的位置，这里提供了一个默认的值
 * @param wasmBinary wasm 二进制数据
 * @param fontspath 字体文件的路径
 * @param networkFonts 网络字体的数组
 * @returns 返回一个 Promise 对象，其中包含 MxCppType 类型的实例
 * @example
 * ```ts
	import { loadMxCADassembly } from "mxcad"

	// 调用 loadMxCADassembly 函数并处理返回的 Promise
	loadMxCADassembly(
	  (MxCpp) => {
		console.log('MxCAD assembly 已加载');
		// 在这里可以对 MxCAD assembly 进行操作
	  },
	  // 可选参数，你可以根据需要提供定位函数和其他参数
	).then((MxCpp) => {
	  console.log('MxCAD assembly 加载完成');
	  // 在这里可以继续处理加载完成后的 MxCAD assembly
	}).catch((error) => {
	  console.error('加载 MxCAD assembly 时出错：', error);
	});
 * ```
 */
export declare function loadMxCADassembly(call?: (MxCpp: MxCppType) => void, locateFile?: any, wasmBinary?: ArrayBuffer, fontspath?: string, networkFonts?: string[], mxcad?: any, wasmx64?: any): Promise<MxCppType>;
/**
 * 检查浏览器类型和版本
 * @returns { object } ok 布尔值，表示浏览器是否符合要求 | error 如果浏览器不符合要求，则包含错误信息；否则为空字符串 | var 包含了浏览器信息的对象
 * @example
 * ```ts
  import { MxCheckTheBrowser } from 'mxcad';

  const browserCheckResult = MxCheckTheBrowser();
  if (browserCheckResult.ok) {
	console.log('浏览器符合要求，可以加载 MxCAD assembly。');
	// 在这里调用 loadMxCADassembly 函数加载 MxCAD assembly
  } else {
	console.error('浏览器不符合要求：', browserCheckResult.error);
	// 在这里处理浏览器不符合要求的情况，可能给出用户友好的提示或者采取其他措施
  }
 * ```
 */
export declare function MxCheckTheBrowser(): {
	ok: boolean;
	error: string;
	var: any;
};
export declare function Mx_About(): void;
/**
 * createMxCad 的参数配置
 * @example
 * ```ts
   createMxCad({
	 canvas: "#mxcad",
	 locateFile: (fileName) => new URL(`/node_modules/mxcad/dist/wasm/2d/${fileName}`, import.meta.url).href,
	 // 提供要打开的文件 注意../assets/test.mxweb 是相对路径下的文件地址,
	 // 在vite中可用通过这样的方式得到该文件正确的的网络地址
	 fileUrl: new URL("../assets/test.mxweb", import.meta.url).href,
	 // 提供加载字体的目录路径
	 fontspath: new URL("node_modules/mxcad/dist/fonts", import.meta.url).href,
	 viewBackgroundColor:{red:0,green:0,blue:0}, //黑色背景
	 middlePan:false, //禁用鼠标中间键操作
	 multipleSelect: true, // 开启多选
	 onOpenFileComplete:()=>{
	   console.log("成功打开文件！")
	 }
   })
 * ```
 */
export interface MxCadConfig {
	/** 获取加载wasm相关文件(wasm/js/worker.js)路径位置
	 * @param fileName wasm相关的文件名称
	 * @param base 相对于js调用位置的http URL绝对路径
	 * @returns filePath 默认采用base + fileName
	 * @abstract 本质上locateFile配置函数就是返回wasm相关文件在自己的服务器上的位置
	 *           在npm包中`node_modules/mxcad/dist/wasm/2d/`下的文件就是支持2d的相关wasm文件
	 */
	locateFile?: (fileName: string, base?: string | URL) => string;
	/**  WebAssembly 模块二进制文件 默认情况无需配置 **/
	wasmBinary?: ArrayBuffer;
	/**
	 * 当通过 MxFun.getCurrentDraw 未发现当前mxDraw实例时，
	 * 会通过 canvas属性(值可以是css选择器字符串也可以是一个canvas元素)来创建mxdraw实例
	 * 如果想要获得这个mxDraw实例 只需要调用mxdraw包中导出的 MxFun.getCurrentDraw方法即可
	 * 如果gis模式下，canvas变量不会使用，会自动使用mapbox的canvas.
	 *   */
	canvas?: string | HTMLCanvasElement;
	/**
	 * mxdraw和mxcad 核心代码加载完成初始化的回调
	 * onInit默认值函数如下实例所示（请根据你的业务需求自行修改）
	 * @example
	 * ```js
	 * import { MxFun } from "mxdraw"
	 * onInit() {
	 *  MxFun.setIniset({
	 *       // 启用对象选择功能.
	 *      EnableIntelliSelect: true,
	 *       // 是否开启多个选择
	 *      multipleSelect: false,
	 *   });
	 * }
	 * ```
	 * */
	onInit?: Function;
	/** 需要初始化打开的文件url路径 */
	fileUrl?: string;
	/**
	 * 监听打开文件成功回调事件
	 */
	onOpenFileComplete?: Function;
	/** 字体文件加载路径，默认是fonts */
	fontspath?: string;
	/** 服务器上可供加载的字体列表 */
	networkFonts?: string[];
	/** 打开文件参数设置，如，打开文件不使用缓存：{fetchAttributes:FetchAttributes.EMSCRIPTEN_FETCH_LOAD_TO_MEMORY}*/
	openParameter?: object;
	/**鼠标中间键操作设置,默认为鼠标中间移动视区，默认值1 */
	/**  iMethod = 0,中键不移动视区，左键移动
	* iMethod = 1,中键移动视区，左键不移动
	* iMethod = 2,中键移动视区，左键移动视区*/
	middlePan?: number | boolean;
	/**注册数据 */
	registdata?: string;
	/**注册文件 */
	registfile?: string;
	/**授权服务 */
	authorized_service?: string;
	/**
	 * 视区背景颜色
	 */
	viewBackgroundColor?: {
		red: number;
		green: number;
		blue: number;
	};
	/**地图模块 */
	map?: any;
	/**多选模式,框选功能,默认值是false */
	multipleSelect?: boolean;
	/**是否启用Undo,默认没有启用 */
	enableUndo?: boolean;
	/**是否启用选择功能，默认是使用 */
	enableIntelliSelect?: boolean;
	/**是否启用浏览模式，默认是编辑模式 */
	/**true或1,启用浏览模式，CAD对象不能选中
	/*2,启用浏览模式，CAD对象能选中,但不能夹点编辑*/
	browse?: boolean | number;
	/**是否使用webgl1方式启动 */
	webgl1?: boolean;
	/**是否加载64位的wasm,默认加载32位 */
	wasmx64?: boolean;
}
/** 创建MxCad实例
 * @param config 参数配置
 * @param mxcadobj 对象
 * @example
 * //通过创建实例实现图纸展示以下基于vite打包工具
 * ```ts
 * import { createMxCad } from "mxcad";
 *
 * createMxCad({
 *   canvas: "#mxcad",
 *   locateFile: (fileName) => new URL(`/node_modules/mxcad/dist/wasm/2d/${fileName}`, import.meta.url).href,
 *   // 提供要打开的文件 注意../assets/test.mxweb 是相对路径下的文件地址,
 *   // 在vite中可用通过这样的方式得到该文件正确的的网络地址
 *   fileUrl: new URL("../assets/test.mxweb", import.meta.url).href,
 *   // 提供加载字体的目录路径
 *   fontspath: new URL("node_modules/mxcad/dist/fonts", import.meta.url).href,
 * })
 * ```
 */
export declare const createMxCad: (config?: MxCadConfig, mxcadobj?: McObject) => Promise<McObject>;
/** 绘制文字
 * @param height 文字高度
 * @param text 文字内容
 * @param position 文字位置
 * @param angle 文件角度
 * @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<McObjectId | undefined>;
/** 绘制正多边形 */
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>;
export declare function MxRegistCommand(): void;
/**
 * 将数据进行 Base64 编码
 * @param str 目标数据
 * @return Base64 编码
*/
export declare function b64Encode(str: string): string;
/**
 * 将 Base64 编码的字符串解码为原始数据
 * @param str Base64 编码
 * @returns 原始数据
 */
export declare function b64Decode(str: string): string;
/**
 * 把字符串转成16进制格式编辑
 * @string str 目标字符串
 * @return 16进制字符串
 */
export declare function crateHexString(str: string): string;
export type FileTypes = {
	description?: string;
	accept: {
		[type: string]: string[];
	};
}[];
/**
 *  文件下载保存弹框（另存为只支持 Chrome86 或 Edge 86 以及 Opera 72）兼容 iE10等较低版本的浏览器
 * @param blob 要保存的文件数据
 * @param filename 保存的文件名
 * @param types 文件类型
 * @example
 * ```ts
 * // 导出DWG文件
	import { MxCpp, MxTools } from "mxcad";

	async function Mx_Export_DWG() {
		const baseUrl = "http://localhost:1337";
		const mxfilepath = "/mxcad/file/";
		const saveDwgUrl = baseUrl + "/mxcad/savedwg";
		// 把mxweb文件 ，保存到服务器上，然后转换成 dwg文件 ，再下载。
		MxCpp.getCurrentMxCAD().saveFileToUrl(saveDwgUrl, (iResult: number, sserverResult: string) => {
			try {
				let ret = JSON.parse(sserverResult);
				if (ret.ret == "ok") {
					let filePath = baseUrl + mxfilepath + ret.file;
					fetch(filePath).then(async (res) => {
						const blob = await res.blob()
						MxTools.saveAsFileDialog({
							blob,
							filename: ret.file,
							types: [{
								description: "dwg图纸",
								accept: {
									"application/octet-stream": [".dwg"],
								},
							}]
						})
					})
				}
				else {
					console.log(sserverResult);
				}
			} catch {
				console.log("Mx: sserverResult error");
			}
		});
	};
 * ```
 */
export declare function saveAsFileDialog({ blob, filename, types }: {
	blob: Blob;
	filename?: string;
	types?: FileTypes;
}): Promise<false | (FileSystemFileHandle & {
	createWritable: () => Promise<WritableStreamDefaultWriter<any>>;
}) | undefined>;
/**
 * 在浏览器中下载一个文件
 * @param blob Blob 对象，它包含了要下载的文件的数据
 * @param filename 将要保存的文件的文件名
 */
export declare function downloadFile(blob: any, filename: string): void;
/**
 * 从指定的 URL 下载文件到用户的计算机中
 * @param url 下载文件的 URL 地址
 * @param filename 将要保存的文件的文件名
 */
export declare function downloadFileFromUrl(url: string, filename: string): void;
/**
 * 从指定URL中获取文件json字符串
 * @param url 文件的 URL 地址
 * @returns json字符串
 */
export declare const getJsonFromUrl: (url: string) => Promise<any>;
/**
 * 从指定URL中获取文件
 * @param url 文件的 URL 地址
 * @returns 目标文件
 */
export declare const getFileFromUrl: (url: string) => Promise<Response | undefined>;
/** 接收输入的提示字符串
 * @param strId 字符串的ID 起一个符合定义的ID名称
 * @param str 提示字符串
 *  */
export declare function _ML_String(strId: string, str: string): string;
/**
 * 检查一个数值是否接近于零的
 * @param val 数值
 * @returns 布尔值
 */
export declare function IsZero(val: number): boolean;
/**
 * 将内存中的数据发送到指定的 URL，以实现文件上传功能
 * @param memoryData 内存中数据的对象或者数据结构
 * @param url 数据将要发送到的目标 URL 地址
 * @param filename 上传的文件的文件名
 * @param retCall 回调函数
 * @param param 可选的额外参数，可以用来传递额外的数据或配置信息给上传函数
 */
export declare function postMemoryFile(memoryData: any, url: string, filename: string, retCall: (code: number, message: string) => void, param?: any): void;
/**
 * 从 IndexedDB（Indexed Database，索引数据库）中获取文件，并将其上传到指定的 URL
 * @param filekey 从 IndexedDB 中获取的文件的键（key）
 * @param url 数据将要发送到的目标 URL 地址，用于上传文件
 * @param retCall 回调函数
 * @param param 可选的额外参数，可以用来传递额外的数据或配置信息给上传函数
 */
export declare function postEmscriptenIndexedDBFile(filekey: string, url: string, retCall: (code: number, message: string) => void, param?: any): void;
/**
 * 创建一个自定义的鼠标光标对象
 * @description
 * 该函数会根据传入的参数，生成一个包含不同类型光标的对象，包括矩形、十字、普通和抓取光标。
 * @param cursorSize 鼠标大小
 * @param targetFrameSize 目标框大小
 * @param color 光标颜色
 * @returns
 */
export declare function createCursor(cursorSize?: number, targetFrameSize?: number, color?: string): any;
/**
 * 创建一个 MdGeLongLongArray 对象，并将传入的 McObjectId 数组中的 id 值添加到该对象中。
 * @param aryId McObjectId 数组
 * @returns MdGeLongLongArray 对象
 * @description
 * 该函数会创建一个新的 MdGeLongLongArray 对象，并遍历传入的 McObjectId 数组，将每个对象的 id 值添加到 MdGeLongLongArray 中。
 * 该函数主要用于在 MxCAD 中处理对象 ID 的集合，以便进行批量操作或传递给其他函数使用。
 * @example
 * ```ts
 * import { MxCADUtility, MxCADResbuf, MxCpp } from "mxdraw";
 * // 选择多个对象并合并它们
	async function Mx_Join() {
	  let filter = new MxCADResbuf();
	  filter.AddMcDbEntityTypes("LWPOLYLINE,ARC,LINE");
	  let aryId = await MxCADUtility.userSelect("选择要合并的对象", filter);
	  if (aryId.length == 0) {
		return;
	  }
	  
	  MxCpp.App.MxCADAssist.MxJoin(createMdGeLongLongArrayFormAryId(aryId));
	}
 * ```
 */
export declare function createMdGeLongLongArrayFormAryId(aryId: McObjectId[]): any;
/**
 * 复制一个 McDbEntity 对象的属性到另一个 McDbEntity 对象中
 * @param fromEnt 源 McDbEntity 对象
 * @param toEnt 目标 McDbEntity 对象
 * @description
 * 该函数会将源对象的图层、线型、线型比例、线宽、真实颜色和文字样式等属性复制到目标对象中。
 * 该函数主要用于在 MxCAD 中进行对象属性的批量复制，以便快速创建具有相同属性的新对象。
 */
export declare function copyMcDbEntityProperties(fromEnt: McDbEntity, toEnt: McDbEntity): void;
export declare const MxTools: {
	b64Encode: typeof b64Encode;
	b64Decode: typeof b64Decode;
	saveAsFileDialog: typeof saveAsFileDialog;
	downloadFile: typeof downloadFile;
	downloadFileFromUrl: typeof downloadFileFromUrl;
	getJsonFromUrl: (url: string) => Promise<any>;
	getFileFromUrl: (url: string) => Promise<Response | undefined>;
	_ML_String: typeof _ML_String;
	IsZero: typeof IsZero;
	postEmscriptenIndexedDBFile: typeof postEmscriptenIndexedDBFile;
	postMemoryFile: typeof postMemoryFile;
	createCursor: typeof createCursor;
	createMdGeLongLongArrayFormAryId: typeof createMdGeLongLongArrayFormAryId;
	copyMcDbEntityProperties: typeof copyMcDbEntityProperties;
};
/**
 * Canvas 转图片工具类，用于把浏览器中的 canvas 内容转换为图片并支持下载或生成图片元素。
 *
 * @description
 * 该类主要用于在前端页面中将 canvas 绘制结果导出为 PNG、JPEG、BMP、GIF 等常见图片格式，适用于截图、图表导出、图形分享和本地保存等场景。
 * 它能完成：
 * - 判断当前环境是否支持 canvas、toDataURL、ImageData 等能力；
 * - 按指定宽高对 canvas 进行缩放；
 * - 将 canvas 转成 DataURL 或图片对象；
 * - 保存为图片文件到本地；
 * - 对 BMP 类型做特殊编码以生成可下载的位图内容。
 *
 * 使用方式：
 * 1. 实例化 MxCanvas2Image；
 * 2. 传入 canvas 元素或元素 id；
 * 3. 调用 saveAsImage() 下载图片，或调用 convertToImage() 获取图片节点；
 * 4. 可通过 width、height、type 参数控制导出尺寸和格式；
 * 5. 若需导出 BMP，可按底层编码方式自动生成位图数据。
 *
 * 总结：MxCanvas2Image 是一个专门处理 canvas 导出与下载的工具类，适合在 Web 端把绘制内容快速转换为可保存的图片文件或可展示的 IMG 元素。
 *
 * @example
 * ```ts
 * import { MxCanvas2Image } from "mxcad";
 *
 * const canvas = document.getElementById("myCanvas") as HTMLCanvasElement;
 * const converter = new MxCanvas2Image(document);
 *
 * // 直接下载为 PNG
 * converter.saveAsImage(canvas, 800, 600, "png");
 *
 * // 转成图片节点并插入页面
 * const img = converter.convertToImage(canvas, 800, 600, "jpg");
 * document.body.appendChild(img);
 *
 * // 转成 bmp 并下载
 * converter.saveAsImage(canvas, 1024, 768, "bmp");
 * ```
 */
export declare class MxCanvas2Image {
	private $support;
	private downloadMime;
	private mydocument;
	constructor(in_document?: any);
	private scaleCanvas;
	private getDataURL;
	private saveFile;
	private genImage;
	private fixType;
	private encodeData;
	private getImageData;
	private makeURI;
	private genBitmapImage;
	/**
	 * 将当前 canvas 转换为图片并保存到本地。
	 * @description
	 * 该方法会根据传入的 canvas 元素或其 id，按指定的宽高和图片类型，将 canvas 内容转换为图片，并触发浏览器下载。
	 * @param canvas canvas 元素或其 id。
	 * @param width 导出图片的宽度，若未指定则使用 canvas 原始宽度。
	 * @param height 导出图片的高度，若未指定则使用 canvas 原始高度。
	 * @param type 导出图片的类型，可选值为 'png'、'jpeg'、'bmp'、'gif'，默认值为 'png'。
	 */
	saveAsImage(canvas: any, width: any, height: any, type: any): void;
	/**
	 * 将当前 canvas 转换为图片元素。
	 * @description
	 * 该方法会根据传入的 canvas 元素或其 id，按指定的宽高和图片类型，将 canvas 内容转换为图片，并返回一个 HTMLImageElement 对象，可直接插入页面。
	 * @param canvas canvas 元素或其 id。
	 * @param width 导出图片的宽度，若未指定则使用 canvas 原始宽度。
	 * @param height 导出图片的高度，若未指定则使用 canvas 原始高度。
	 * @param type 导出图片的类型，可选值为 'png'、'jpeg'、'bmp'、'gif'，默认值为 'png'。
	 * @returns
	 */
	convertToImage(canvas: any, width: any, height: any, type: any): HTMLImageElement | undefined;
}
export type Map = any;
/**
 * Mapbox 地图与 CAD 坐标系统桥接类，用于将地图坐标和 CAD 绘图坐标相互转换。
 *
 * @description
 * MxMap 是一个用于连接 Mapbox 地图和 MxCAD/AutoCAD 坐标体系的桥接对象，主要用于在地理地图场景中与 CAD 图纸协同工作。
 * 它能够完成：
 * - 绑定 Mapbox map 实例；
 * - 在经纬度、墨卡托坐标和 CAD 坐标之间进行转换；
 * - 处理地图缩放和 CAD 坐标系的对齐；
 * - 通过 create() 方法生成地图自定义图层并接入 CAD 渲染环境；
 * - 适配旧版和新版地图创建方式。
 *
 * 使用方式：
 * 1. 实例化 MxMap，并可选择传入已有的 McObject；
 * 2. 调用 setCoordinatePointAlignment() 设置地图原点和 CAD 原点关系；
 * 3. 通过 initMapbox() 绑定 mapbox 实例；
 * 4. 调用 create(map, config) 启动地图与 CAD 的集成渲染；
 * 5. 使用 lnglatToCAD()、mercatorCoord2CAD() 等方法执行坐标转换。
 *
 * 总结：MxMap 是连接地图地理坐标与 CAD 绘图坐标的核心工具，适合做地理信息、地图定位、测绘数据与工程图协同展示场景。
 */
export declare class MxMap {
	private imp;
	private map;
	private originLngLatLike;
	private originCAD;
	private meterInCADUnits;
	private modelAltitude;
	private loadOldEditionMethod;
	/**mxcad对象 */
	mxcad: McObject;
	constructor(inMxcad?: McObject);
	/**
	 * 用于设置加载旧版本地图
	 */
	setLoadOldEditionMethod(): void;
	/**
	 * 获取当前mxdraw对象
	 * @return mxdraw对象
	 * */
	getMxDrawObject(): MxDrawObject;
	/**
	 * 初始化mapbox
	 * @param map map对象
	 */
	initMapbox(map: Map): void;
	/**
	 * 获取mapbox的map对象
	 * @return map对象
	 */
	getMapbox(): Map;
	/**
	 * mapbox的墨卡托坐标系到cad
	* @param x X轴坐标
	* @param y Y轴坐标
	* @returns 三维点对象
	 */
	mercatorCoord2CAD(x: number, y: number): THREE.Vector3;
	/**
	 * mapbox的墨卡托坐标系到cad
	 * @param x X轴坐标
	 * @param y Y轴坐标
	 * @returns 三维点对象
	 */
	mercatorCoordToCAD(x: number, y: number): THREE.Vector3;
	/**
	 * cad到mapbox的墨卡托坐标系
	 * @param pt 三维点对象
	 * @returns 三维点对象
	 */
	cadToMercatorCoord(pt: THREE.Vector3): THREE.Vector3;
	/**
	 * 经纬度到cad坐标
	 * @param lng 经度
	 * @param lat 纬度
	 * @return 三维点对象
	 */
	lnglatToCAD(lng: number, lat: number): THREE.Vector3;
	/**
	 * cad坐标转换为经度和纬度
	 * @param pt 三维点对象
	 * @returns 经纬度
	 */
	cadTolnglat(pt: THREE.Vector3): number[];
	/**
	 * 地图墨卡托坐标系到经纬度
	 * @param x X轴坐标
	 * @param y Y轴坐标
	 * @returns 经纬度
	 */
	map_meters_to_lnglat(x: number, y: number): number[];
	/**
	 * 将地理坐标系下的坐标（经度和纬度）转换为平面坐标系下的坐标（米）
	 * @param lng 经度
	 * @param lat 维度
	 * @returns 平面坐标
	 */
	map_lnglat_to_meters(lng: number, lat: number): number[];
	/**
	 * 经纬度到mapbox的墨卡托坐标系坐标
	 * @param lng 经度
	 * @param lat 维度
	 * @returns 三维点对象
	 */
	lnglat_to_mercator(lng: number, lat: number): THREE.Vector3;
	/**
	 * mapbox的墨卡托坐标系到经纬度
	 * @param x X轴坐标
	 * @param y Y轴坐标
	 * @param z Z轴坐标
	 * @returns 经纬度
	 */
	mercator_to_lnglat(x: number, y: number, z: number): number[];
	/**
	 * 是否超出中国范围
	 * @param lng 经度
	 * @param lat 维度
	 * @returns 布尔值
	 */
	outOfChina(lng: number, lat: number): boolean;
	/**
	 * 将经度坐标转换为墨卡托投影下的坐标
	 * @param len 经度
	 * @return 墨卡托投影下的坐标
	 */
	cadLongToMercatorCoord(len: number): number;
	/**
	 * 设置坐标点的对齐方式
	 * @param originLngLatLike 经度和纬度的原点坐标
	 * @param originCAD 绘图坐标系下的起始点，即AutoCAD 中的原点坐标。
	 * @param meterInCADUnits 地理坐标系和 AutoCAD 绘图使用的坐标单位转换
	 */
	setCoordinatePointAlignment(originLngLatLike: number[], originCAD: number[], meterInCADUnits: number): void;
	/**
	 * 创建地图
	 * @param map map对象
	 * @param MxCadConfig createMxCad 的参数配置
	 */
	create(map: Map, config: MxCadConfig | any): Promise<void>;
}
/**
 * 加载地图图层
 * @param map map对象
 * @param layerList 图层列表
 * @param key 访问瓦片图层的 API 密钥或者令牌
 * @param providers 指定瓦片图层的提供者信息
 */
export declare function MxMapAddRasterTileLayer(map: any, layerList: any[], key?: string, providers?: any): void;
/**
 * 加载GoogleCnLayer地图图层,火星坐标系
 * @param map map对象
 * @param types 谷歌地图图层的类型
 * @param urls 谷歌地图图层的URL
 */
export declare function MxMapAddGoogleCnLayer(map: any, types: string[], urls?: string[]): void;
/**
 * GPS 坐标（WGS 84 坐标系）转换为国测局坐标（GCJ-02 坐标系）
 * @param lng 经度
 * @param lat 纬度
 * @returns 转换后的经纬度
 */
export declare function mx_gps84_To_gcj02(lng: any, lat: any): {
	lng: any;
	lat: any;
};
/**
 * 国测局坐标（GCJ-02 坐标系）转换为GPS 坐标（WGS 84 坐标系）
 * @param lng 经度
 * @param lat 纬度
 * @returns @returns 转换后的经纬度
 */
export declare function mx_gcj02_To_gps84(lng: any, lat: any): {
	lng: number;
	lat: number;
};
/**
 * TIFF 图像加载器，用于加载和处理 TIFF 格式的图像数据。
 *
 * @description
 * MxTIFFLoader 是一个轻量的 TIFF 文件加载工具，主要用于在前端或 Web 场景中将 TIFF 图片读取为可使用的纹理对象。
 * 它能够完成：
 * - 加载远程 TIFF 文件地址；
 * - 通过底层 TIFFLoader 进行解析；
 * - 提供 onLoad 和 onError 回调处理加载结果；
 * - 允许设置图片反色处理等显示参数。
 *
 * 使用方式：
 * 1. 实例化 MxTIFFLoader；
 * 2. 调用 load(url, onLoad, onError) 加载 TIFF 文件；
 * 3. 在回调中获取纹理数据并继续进行显示或处理；
 * 4. 如需反色，可调用 setInverse(true) 调整显示效果。
 *
 * 总结：MxTIFFLoader 是 TIFF 格式图像的加载与展示桥接类，适合在需要读取遥感、栅格图或高分辨率影像的项目中使用。
 */
export declare class MxTIFFLoader {
	private imp;
	load(url: string, onLoad?: (texture: any) => void, onError?: (event: any) => void): void;
	setInverse(val: boolean): void;
}

export {};