@lcap/nasl 3.9.1-beta.13 → 3.9.1-beta.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lcap/nasl",
   "description": "NetEase Application Specific Language",
-  "version": "3.9.1-beta.13",
+  "version": "3.9.1-beta.15",
   "author": "Forrest <rainforest92@126.com>",
   "main": "./out",
   "types": "./out/index.d.ts",
@@ -70,16 +70,16 @@
     "socket.io-client": "2.4.0",
     "uuid": "8.3.2",
     "vue-template-compiler": "2.6.14",
-    "@lcap/nasl-breakpoint": "3.9.1-beta.13",
-    "@lcap/nasl-concepts": "3.9.1-beta.13",
-    "@lcap/nasl-language-server-core": "3.9.1-beta.13",
-    "@lcap/nasl-log": "3.9.1-beta.13",
-    "@lcap/nasl-sentry": "3.9.1-beta.13",
-    "@lcap/nasl-translator": "3.9.1-beta.13",
-    "@lcap/nasl-types": "3.9.1-beta.13",
-    "@lcap/nasl-typescript-worker": "3.9.1-beta.13",
-    "@lcap/nasl-unified-frontend-generator": "3.9.1-beta.13",
-    "@lcap/nasl-utils": "3.9.1-beta.13"
+    "@lcap/nasl-language-server-core": "3.9.1-beta.15",
+    "@lcap/nasl-concepts": "3.9.1-beta.15",
+    "@lcap/nasl-sentry": "3.9.1-beta.15",
+    "@lcap/nasl-breakpoint": "3.9.1-beta.15",
+    "@lcap/nasl-log": "3.9.1-beta.15",
+    "@lcap/nasl-translator": "3.9.1-beta.15",
+    "@lcap/nasl-types": "3.9.1-beta.15",
+    "@lcap/nasl-typescript-worker": "3.9.1-beta.15",
+    "@lcap/nasl-unified-frontend-generator": "3.9.1-beta.15",
+    "@lcap/nasl-utils": "3.9.1-beta.15"
   },
   "devDependencies": {
     "@types/babel__core": "7.20.1",
@@ -91,8 +91,8 @@
     "rimraf": "3.0.2",
     "typedoc": "0.25.13",
     "typescript": "5.4.4",
-    "@lcap/nasl-test-toolkit": "1.0.0",
-    "@lcap/nasl-tsconfig": "1.0.1"
+    "@lcap/nasl-tsconfig": "1.0.1",
+    "@lcap/nasl-test-toolkit": "1.0.0"
   },
   "scripts": {
     "clear": "rimraf ./out",

package/sandbox-natural/stdlib/nasl.core.d.ts

@@ -1,13 +1,12 @@
-/* 基本类型定义 */
+// 基本类型定义
 type Any = any;
 type Long = number;
-type Integer = number;
 type Decimal = number;
 type Boolean = boolean;
 type String = string;
-type List<T> = Array<T>;
-
+/* 日期类型 */
 type Date = globalThis.Date;
+/* 时间类型 */
 class Time {
   accept: 'Time';
 }
@@ -15,25 +14,39 @@ class Time {
 class DateTime {
   accept: 'DateTime';
 }
+type List<T> = Array<T>;
+
+/*
+ * 循环函数ForEach
+ * 这是唯一一个可以在逻辑中使用的循环函数，用于遍历列表中的元素，禁止使用for、while等其他循环语句。
+ */
+declare function ForEach<T>(list: List<T>, start: Long, end: Long, fn: (item: T, index: Long) => void): void;
+
+// 基本运算函数，用于数学计算
+declare function plus(left: Decimal, right: Decimal): Decimal;
+declare function minus(left: Decimal, right: Decimal): Decimal;
+declare function multiply(left: Decimal, right: Decimal): Decimal;
+declare function divide(left: Decimal, right: Decimal): Decimal;
+declare function remainder(left: Decimal, right: Decimal): Decimal;
 
 /**
  * 数据实体接口
- * 作用：创建、更新和删除数据表中的数据
+ * 作用：查询、创建、更新和删除数据表中的数据
 */
 interface Entity<T> {
   /* 根据主键ID获取一条数据 */
-  get(id: Integer): T;
+  get(id: Long): T;
   /**
    * 将传入的数据实体插入到数据表中
    * @param entity 数据实体，T类型。不包含id, createTime, updateTime, createdBy, updatedBy字段
    * @returns 返回插入的数据实体，T类型。已自动生成id, createTime, updateTime, createdBy, updatedBy字段, 可以通过返回值获取插入数据在数据库中的id
-   * @example const person = nasl.util.NewEntity<app.dataSources.defaultDS.entities.Person>({name: 'test', age: 18}; insertPerson = app.dataSources.defaultDS.entities.PersonEntity.create(person); // 可以根据insertPerson.id获取插入数据在数据库中的id
+   * @example const person = nasl.util.NewEntity<Person>({name: 'test', age: 18}; insertPerson = PersonEntity.create(person); // 可以根据insertPerson.id获取插入数据在数据库中的id
   */
   create(entity: T): T;
   /* 根据传入的数据对象更新数据表中的数据 */
   update(entity: T): T;
   /* 根据主键ID删除数据表中的数据 */
-  delete(id: Integer): void;
+  delete(id: Long): void;
   /* 根据传入的数据对象创建或更新数据表中的数据 */
   createOrUpdate(body: T): T;
   /* 根据主键ID列表批量删除数据表中的数据 */
@@ -41,14 +54,37 @@ interface Entity<T> {
   /* 根据传入的数据对象列表批量更新数据表中的数据 */
   batchUpdate(list: List<T>): List<T>;
   /* 根据主键ID列表批量删除数据表中的数据 */
-  batchDelete(list: List<Integer>): void;
+  batchDelete(list: List<Long>): void;
 }
-
 /*
 * createEntity函数：根据数据表类型创建一个数据实体接口，然后通过该接口调用数据表中的数据。
-* @example const LCAPUserEntity = createEntity<app.dataSources.defaultDS.entities.LCAPUser>(); app.dataSources.defaultDS.entities.LCAPUserEntity.delete(id);
+* @example const LCAPUserEntity = createEntity<LCAPUser>(); LCAPUserEntity.delete(id);
 * 注意：对应接口已经在下面的实体列表中定义好了，不需要重新定义。
 */
 declare const createEntity: <T>() => Entity<T>;
 /* EntityRelation函数：用于定义数据表内的外键关联关系。*/
-declare function EntityRelation(property: any): any;
+declare function EntityRelation(property: any): any;
+
+/* 系统逻辑: 认证与权限 */
+declare namespace nasl.auth {
+  /* 判断当前登录用户是否拥有该资源路径的访问权限 */
+  export function hasAuth(authPath: String): Boolean;
+  /* 退出当前登录状态，无输出参数 */
+  export function logout(): void;
+  /* 将输入的字符串使用AES算法进行加密, 输出参数为一个加密后的字符串 */
+  export function encryptByAES(rawStr: String): String;
+  /* 对加密的字符串使用AES算法进行解密, 输出参数为一个解密后的字符串 */
+  export function decryptByAES(encryptedStr: String): String;
+  /* 当前登录用户信息 */
+  export const userInfo: {
+    Status: String;
+    UserName: String;
+    Email: String;
+    UserId: String;
+    Phone: String;
+    CreateTime: Long;
+    UpdateTime: Long;
+    LoginCount: Long;
+    Source: String;
+  };
+}

package/sandbox-natural/stdlib/nasl.coreApp.d.ts

@@ -0,0 +1,99 @@
+// 基本类型定义
+type Any = any;
+type Long = number;
+type Decimal = number;
+type Boolean = boolean;
+type String = string;
+/* 日期类型 */
+type Date = globalThis.Date;
+/* 时间类型 */
+class Time {
+  accept: 'Time';
+}
+/* 日期时间类型 */
+class DateTime {
+  accept: 'DateTime';
+}
+type List<T> = Array<T>;
+
+/*
+ * 循环函数ForEach
+ * 这是唯一一个可以在逻辑中使用的循环函数，用于遍历列表中的元素，禁止使用for、while等其他循环语句。
+ */
+declare function ForEach<T>(list: List<T>, start: Long, end: Long, fn: (item: T, index: Long) => void): void;
+
+/* 基本运算函数，用于数学计算 */
+declare function plus(left: Decimal, right: Decimal): Decimal;
+declare function minus(left: Decimal, right: Decimal): Decimal;
+declare function multiply(left: Decimal, right: Decimal): Decimal;
+declare function divide(left: Decimal, right: Decimal): Decimal;
+declare function remainder(left: Decimal, right: Decimal): Decimal;
+
+/* 分页组件函数，用于分页 */
+declare function PAGINATE<T>(list: List<T>, page: Long, size: Long): { list: List<T>, total: Long; };
+
+/**
+ * 数据库操作函数系列
+ * 平台提供两种数据库操作方式：SQL语言和数据实体接口。二者分别适用于不同的场景：
+ * 使用SQL语言进行查询操作，使用数据实体接口进行增删改操作。
+ */
+
+/**
+ * SQL数据查询, 只使用该方法进行数据查询
+ * @param sql 数据查询需要的 SQL
+ * @returns 返回查询结果列表
+ * 
+ * 关于T的类型说明：
+ *  1. 如果查询字段均来自一个数据表，T为该数据表的类型
+ *  2. 如果查询字段来自多个数据表，那么T为匿名类型，包含所有查询字段, 如：{name: string, age: number}
+ * 在调用时，T可以不指定，平台会自动进行推断
+ *
+ * 优先使用数据库的查询和数据操纵能力，例如 JOIN、SUM、GROUP_BY 等
+ * 所有变量格式为：${variable}，不能用''包裹，不能用函数处理。
+ * @example `SELECT * FROM Student WHERE id = ${id}`
+ * @example `SELECT OrderProduct.*, Product.price as price FROM OrderProduct JOIN Product ON OrderProduct.productId = Product.id WHERE orderId = ${id}`
+ * 
+ * 关于返回值类型, 可能是列表或单个值, 根据具体的SQL语句来确定。
+ * @example `SELECT SUM(price) FROM Goods` -> T
+ * @example `SELECT SUM(price) FROM Goods GROUP BY user` -> List<T>
+ * @example `SELECT * FROM Goods` -> List<T>
+ */
+declare namespace nasl.oql {
+  export function query<T>(sql: string): List<T> | T;
+}
+
+/**
+ * 数据实体接口
+ * 作用：数据库增删改操作
+*/
+interface Entity<T> {
+  /* 根据主键获取一条数据。注意：该方法仅支持使用主键进行查询, 且只返回一条数据 */
+  get(id: Long): T;
+  /**
+   * 将传入的数据实体插入到数据表中
+   * @param entity 数据实体，T类型。不包含id, createTime, updateTime, createdBy, updatedBy字段
+   * @returns 返回插入的数据实体，T类型。已自动生成id, createTime, updateTime, createdBy, updatedBy字段, 可以通过返回值获取插入数据在数据库中的id
+   * @example const person = nasl.util.NewEntity<Person>({name: 'test', age: 18}; insertPerson = PersonEntity.create(person); // 可以根据insertPerson.id获取插入数据在数据库中的id
+  */
+  create(entity: T): T;
+  /* 根据传入的数据对象更新数据表中的数据 */
+  update(entity: T): T;
+  /* 根据主键删除数据表中的数据 */
+  delete(id: Long): void;
+  /* 根据传入的数据对象创建或更新数据表中的数据 */
+  createOrUpdate(body: T): T;
+  /* 根据主键列表批量删除数据表中的数据 */
+  batchCreate(list: List<T>): List<T>;
+  /* 根据传入的数据对象列表批量更新数据表中的数据 */
+  batchUpdate(list: List<T>): List<T>;
+  /* 根据主键列表批量删除数据表中的数据 */
+  batchDelete(list: List<Long>): void;
+}
+/*
+* createEntity函数：根据数据表类型创建一个数据实体接口，然后通过该接口调用数据表中的数据。
+* @example const LCAPUserEntity = createEntity<LCAPUser>(); LCAPUserEntity.delete(id);
+* 注意：对应接口已经在下面的实体列表中定义好了，不需要重新定义。
+*/
+declare const createEntity: <T>() => Entity<T>;
+/* EntityRelation函数：用于定义数据表内的外键关联关系。*/
+declare function EntityRelation(property: any): any;

package/sandbox-natural/stdlib/nasl.ui.d.ts

@@ -1,5 +1,8 @@
+/* UI组件基础库 */
 declare namespace nasl.ui {
-  /* 校验类型 */
+  /* 表单检验类型，用于表单校验函数
+  * @example let formValidate: ValidateResult = $refs.form2.validate(); 
+  */
   export interface ValidateResult { valid: Boolean; }
   /* current: 推导类型 */
   export class Current<T> {
@@ -57,34 +60,11 @@ declare namespace nasl.ui {
     getPropValue<K extends ViewComponentOptionGetKeys>(key: K): ViewComponentOptions[K];
   }
 
-  // 在页面上弹出消息
+  /* 在页面上弹出消息 */
   export function showMessage(text: Any): void;
   /** 跳转到指定页面
    * @example nasl.ui.destination('pageType.some_view.sub1_view', { param1, param2, ... });
    * pageType 为 namespace，如 pc 或者 m，必填
    */
   export function destination(path: String, args: object): void;
-}
-
-declare namespace nasl.auth {
-  // 检查当前用户是否有当前资源的权限
-  export function hasAuth(authPath: String): Boolean;
-  // 退出当前登录状态
-  export function logout(): void;
-  // 对字符串 实现aes加密，返回加密后的字符串
-  export function encryptByAES(authPath: String): String;
-  // 对字符串 实现aes解密，返回解密后的字符串
-  export function decryptByAES(authPath: String): String;
-  // 获取用户信息
-  export const userInfo: {
-    Status: String;
-    UserName: String;
-    Email: String;
-    UserId: String;
-    Phone: String;
-    CreateTime: Long;
-    UpdateTime: Long;
-    LoginCount: Long;
-    Source: String;
-  };
-}
+}

package/sandbox-natural/stdlib/nasl.util.d.ts

@@ -1,30 +1,27 @@
-/** 循环函数ForEach
-* 这是唯一一个可以在逻辑中使用的循环函数，用于遍历列表中的元素，禁止使用for、forEach等其他循环语句。
-*/
-declare function ForEach<T>(list: List<T>, start: Integer, end: Integer, fn: (item: T, index: Integer) => void): void;
-
-/* 基本运算函数，用于数学计算 */
-declare function plus(left: Decimal, right: Decimal): Decimal;
-declare function minus(left: Decimal, right: Decimal): Decimal;
-declare function multiply(left: Decimal, right: Decimal): Decimal;
-declare function divide(left: Decimal, right: Decimal): Decimal;
-declare function remainder(left: Decimal, right: Decimal): Decimal;
-
+// 内置函数库
 declare namespace nasl.util {
   /* 类型转换与格式化函数 */
+  /* 各基础数据类型之间转换 */
   export function Convert(value: null): <T extends never>() => T;
+  /* 返回格式化的数字字符串 */
   export function FormatNumber(doubleValue: Decimal | Long, digits: Long, showGroups: Boolean): String;
-  // @example nasl.util.FormatDateTime(dataTime1, 'yyyy-MM-dd HH:mm:ss', 'global')
+  /* 返回格式化日期时间字符串 */
+  /* @example nasl.util.FormatDateTime(nasl.util.CurrDateTime(), 'yyyy-MM-dd HH:mm:ss', 'global') */
   export function FormatDateTime(dateTime: DateTime, formatter: String, timeZone: string): String;
+  /* 返回格式化日期字符串 */
+  /* @example nasl.util.FormatDate(nasl.util.CurrDate(), 'yyyy-MM-dd') */
   export function FormatDate(date: Date, formatter: String): String;
-  // @example nasl.util.FromString<Date>(variable1)
+  /* 字符串转换成其他类型 */
+  /* @example nasl.util.FromString<Date>('2021-01-01') */
   export function FromString<T extends Decimal | Date | Time | DateTime | Long | Boolean>(value: String): T;
+  /* 各类型转换成字符串 */
   export function ToString(value: Any): String;
 
   /* 字符串函数 */
   export function Length(str1: String): Decimal;
   export function Length<K, V>(str1: Map<K, V>): Decimal;
   export function Length<T>(str1: List<T>): Decimal;
+  /* 用于查找字符串中指定字段所在位置，常用的场景包括字符串匹配、字符串替换、数据校验等 */
   export function IndexOf(str: String, search: String, formIndex: Decimal, ignoreCase: Boolean): Decimal;
   export function Join(list: List<Any>, seperator: String): String;
   export function LastIndexOf(str: String, search: String, ignoreCase: Boolean): Decimal;
@@ -39,23 +36,38 @@ declare namespace nasl.util {
   export function CurrDate(): Date;
   export function CurrDateTime(): DateTime;
   export function CurrTime(): Time;
-  // 计算两个日期时间之间的差值，calcType 支持年、季度、月、周、天、时分秒，默认为 'd'
-  export function DateDiff<T extends Date | Time | DateTime>(dateTime1: T, dateTime2: T, calcType: 'y' | 'q' | 'M' | 'w' | 'd' | 'h' | 'm' | 's', isAbs: Boolean): Decimal;
-  // 为指定日期时间调整增加（减少）时间
+  /**
+  * 返回日期比较结果
+  * @param date1: 日期1
+  * @param date2: 日期2
+  * @param calcType: 计算类型。计算两个日期时间之间的差值，支持年数('y')、季度数('q')、月数('m')、周数('w')、天数('d')、小时数('h')、分钟数('m')、秒数('s')。默认为天数。
+  * @param isAbs: 是否返回绝对值，默认为 true
+  * @returns 根据计算类型返回对应的差值
+  */
+  export function DateDiff<T extends Date | Time | DateTime>(dateTime1: T, dateTime2: T, calcType: 'y' | 'q' | 'm' | 'w' | 'd' | 'h' | 'm' | 's', isAbs: Boolean): Decimal;
+  /* 为指定日期时间调整增加（减少）时间 */
   export function AlterDateTime<T extends Date | DateTime>(dateTime: T, option: 'Increase' | 'Decrease', amount: Long, unit: 'day' | 'week' | 'month' | 'quarter' | 'year'): T;
-  /** 按指定维度计算日期的序号。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算
+  /**
+  * 按指定维度计算日期的序号。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算
   * @param dateTime: 日期或日期时间
   * @param metric: 计算维度，格式为'小日期单位-大日期单位'。日期单位包括：'year'、'quarter'、'month'、'week'、'day'。如设置 'week-year'，则返回当前日期是所在年的第几周, 'day-week'，则返回当前日期是所在周的第几天。
+  * @param timeZone: 时区，也可填写 'global'，表示全局配置的时区
+  */
+  export function GetDateCount<T extends Date | DateTime>(dateTime: T, metric: String, timeZone: String): Time;
+  /** 
+  * 按“星期几”获取指定日期范围内的日子。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。
+  * @param startDate: 开始日期/日期时间
+  * @param endDate: 结束日期/日期时间
+  * @param target: 目标星期几，1-7分别代表周一到周日
+  * @param timeZone: 时区，也可填写 'global'，表示全局配置的时区
   */
-  export function GetDateCount<T extends Date | DateTime>(dateTime: T, metric: 'week-year'): Time;
-  // 按“星期几”获取指定日期范围内的日子。当输入为 DateTime 类型时，会把数据转到提供的时区的当地时间进行计算。target 取值范围 [1,2,3,4,5,6,7]
-  export function GetSpecificDaysOfWeek<T extends Date | DateTime>(startDate: T, endDate: T, target: List<Long>): List<T>;
+  export function GetSpecificDaysOfWeek<T extends Date | DateTime>(startDate: T, endDate: T, target: List<Long>, timeZone?: String): List<T>;
 
-  /* 列表（List）函数 */
-  export function Add<T, K extends T>(list: List<T>, item: K): void;
-  export function AddAll<T>(list: List<T>, addList: List<T>): Decimal;
-  export function Contains<T, K extends T>(list: List<T>, item: K): Boolean;
-  export function Insert<T, K extends T>(list: List<T>, index: Decimal, item: K): void;
+  // 列表（List）函数
+  export function ListAdd<T, K extends T>(list: List<T>, item: K): void;
+  export function ListAddAll<T>(list: List<T>, addList: List<T>): Decimal;
+  export function ListContains<T, K extends T>(list: List<T>, item: K): Boolean;
+  export function ListInsert<T, K extends T>(list: List<T>, index: Decimal, item: K): void;
   export function ListDistinct<T>(list: List<T>): void;
   export function ListDistinctBy<A>(list: List<A>, by: List<{ items: Array<(elem: A) => any>; }>): List<A>;
   export function ListFilter<T>(list: List<T>, by: (item: T) => Boolean): List<T>;
@@ -73,10 +85,10 @@ declare namespace nasl.util {
   export function ListSum<T extends Long | Decimal>(list: List<T>): T;
   export function ListToMap<T, K extends Boolean | Decimal | Decimal | String, V>(map: List<T>, byKey: (elem: T) => K, byVal: (elem: T) => V): Map<K, V>;
   export function ListTransform<T0, T>(list: List<T0>, by: (elem: T0) => T): List<T>;
-  export function Get<T>(list: List<T>, index: Decimal): T;
-  export function Remove<T, K extends T>(list: List<T>, item: K): void;
-  export function RemoveAt<T>(list: List<T>, index: Long): T;
-  export function Set<T, K extends T>(list: List<T>, index: Decimal, item: K): T;
+  export function ListGet<T>(list: List<T>, index: Decimal): T;
+  export function ListRemove<T, K extends T>(list: List<T>, item: K): void;
+  export function ListRemoveAt<T>(list: List<T>, index: Long): T;
+  export function ListSet<T, K extends T>(list: List<T>, index: Decimal, item: K): T;
 
   /* 映射（Map）函数 */
   export function MapContains<K, V>(map: Map<K, V>, key: K): Boolean;
@@ -86,56 +98,65 @@ declare namespace nasl.util {
   export function MapRemove<K, V>(map: Map<K, V>, key: K): void;
   export function MapValues<K, V>(map: Map<K, V>): List<V>;
 
-  /* 枚举函数，项目中可使用的枚举类型均定义在 app.enums 中 */
-  /** 将指定枚举转换枚举value和text的List集合
-  * @example nasl.util.EnumToList<app.enums.UserSourceEnum>();
-  */
+  /* 枚举函数。项目中的枚举类型均定义在 app.enums 中 */
+  /* 返回枚举value和text的List集合 */
+  /* @example nasl.util.EnumToList<app.enums.UserSourceEnum>() */
   export function EnumToList<T extends Enums>(): List<{ text: String, value: String; }>;
-  // 返回枚举指定value的标题字符串
+  /* 返回枚举指定value的标题字符串 */
   export function EnumItemToText(value: Enums<Long | String>): String;
-  // 在指定枚举中找到与参数相同的枚举值并返回
+  /* 在指定枚举中找到与参数相同的枚举值并返回 */
   export function StringToEnumValue<T extends Enums>(value: String): T;
 
   /* 数学函数 */
-  /** 整数/小数 操作
-   * @param mode: 'HalfUp' | 'TowardsZero' | 'TowardsInfinity' === '四舍五入' | '截断、向零取整，如 -2.6 取整为 -2' | '进位、向正负无穷取整，如 -1.1 取整为 -2'
-   */
+  /**
+  * 整数/小数 操作
+  * @param mode: 'HalfUp' | 'TowardsZero' | 'TowardsInfinity' === '四舍五入' | '截断、向零取整，如 -2.6 取整为 -2' | '进位、向正负无穷取整，如 -1.1 取整为 -2'
+  */
   export function Round(value: Decimal, mode: 'HalfUp' | 'TowardsZero' | 'TowardsInfinity'): Decimal;
-  /* 其他函数 */
+
+  // 其他函数
+  /* （修改原数据）清除复杂对象中每个属性的数据（若输入是单个基础类型如 Integer 的值，则不做处理） */
   export function Clear<T>(struct: T): T;
   export function Clone<T>(struct: T): T;
-  // 判断参数是否为有效值，null、空字符串、纯空格、长度为0的集合均不被视为有效值，传入多个参数时，判断是否全部都是有效值 */
+  /* 判断参数是否为有效值，null、空字符串、纯空格、长度为0的集合均不被视为有效值，传入多个参数时，判断是否全部都是有效值 */
   export function HasValue(...args: Any[]): Boolean;
-  // RandomInt 生成的数字为整数，如果需要指定位数的随机数，需要在数字前按照位数要求补 0
+  /* RandomInt 生成的数字为整数，如果需要指定位数的随机数，需要在数字前按照位数要求补 0 */
   export function RandomInt(start: Long, end: Long): Long;
 
   // New 系列函数使用
-  /** 生成新的列表，T 类型必填
-   * @example const variable1 = nasl.util.NewList<Boolean | Long>([true, false, 1])
-   */
+  /**
+  * 生成新的列表，T 类型必填
+  * @example const variable1 = nasl.util.NewList<Boolean | Long>([true, false, 1])
+  */
   export function NewList<T>(args: T[]): List<T>;
-  /** 生成新的映射，K、T 类型必填
-   * @example const variable1 = nasl.util.NewMap<String, Long>({'123': 456})
-   */
+  /**
+  * 生成新的映射，K、T 类型必填
+  * @example const variable1 = nasl.util.NewMap<String, Long>({'123': 456})
+  */
   export function NewMap<K, T>(args: any): Map<K, T>;
-  /** 生成新的数据实体，T 类型必填
-   * class Entity1 { id: Long; property1: String; property2: String;}
-   * @example const variable1 = nasl.util.NewEntity<Entity1>({id: 123, property1: '123', property2: '456'})
-   */
+  /**
+  * 生成新的数据实体，T 类型必填
+  * class Entity1 { id: Long; property1: String; property2: String;}
+  * @example const variable1 = nasl.util.NewEntity<Entity1>({id: 123, property1: '123', property2: '456'})
+  */
   export function NewEntity<T>(arg: T): T;
-  /** 生成新的结构体，T 类型必填
-   * class Structure1 { id: Long; property1: String; property2: String;}
-   * @example const variable1 = nasl.util.NewStructure<Structure1>({id: 123, property1: '123', property2: '456'})
-   */
+  /**
+  * 生成新的结构体，T 类型必填
+  * class Structure1 { id: Long; property1: String; property2: String;}
+  * @example const variable1 = nasl.util.NewStructure<Structure1>({id: 123, property1: '123', property2: '456'})
+  */
   export function NewStructure<T>(arg: T): T;
-  /** 生成新的匿名结构体, 无需定义类型
-   * @example const variable1 = nasl.util.NewAnonymousStructure({property1: '123', property2: '456'})
-   */
+  /**
+  * 生成新的匿名结构体, 无需定义类型
+  * @example const variable1 = nasl.util.NewAnonymousStructure({property1: '123', property2: '456'})
+  */
   export function NewAnonymousStructure(arg: Any): Any;
 
+  export function consoleLog(arg: Any): void;
   export function jsonSerialize(arg: Any): String;
-  /** JSON 反序列化, T 为返回值类型，必填
-   * @example nasl.util.jsonDeserialize<Boolean>(variable1);
-   */
+  /**
+  * JSON 反序列化, T 为返回值类型，必填
+  * @example nasl.util.jsonDeserialize<Boolean>(variable1);
+  */
   export function jsonDeserialize<T>(arg: String): T;
-}
+}