@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/src/concepts/QueryJoinExpression__.ts

@@ -15,14 +15,15 @@ import type CallQueryComponent from './CallQueryComponent__';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
+
+import BinaryExpression from './BinaryExpression__';
 import LogicItem from './LogicItem__';
-import type BinaryExpression from './BinaryExpression__';
 
 /**
  * 查询 Join 子句
@@ -31,7 +32,11 @@ import type BinaryExpression from './BinaryExpression__';
 export class QueryJoinExpression extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'QueryJoinExpression';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
@@ -41,30 +46,37 @@ export class QueryJoinExpression extends LogicItem {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'QueryJoinExpression';
-
   /**
    * 实体的命名空间
    */
-  @property()
-  entityNamespace!: string;
+  @property({
+    objectRef: '',
+  })
+  entityNamespace: string;
 
   /**
    * 实体名称
    */
-  @property()
-  entityName!: string;
+  @property({
+    objectRef: '',
+  })
+  entityName: string;
 
   /**
    * 别名
    */
-  @property()
-  asName!: string;
+  @property({
+    objectRef: '',
+  })
+  asName: string;
 
   /**
    * joinType
    */
-  @property()
-  joinType!: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+  @property({
+    objectRef: '',
+  })
+  joinType: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
 
   /**
    * 二元表达式列表
@@ -115,7 +127,7 @@ export class QueryJoinExpression extends LogicItem {
     const excludedSet = new Set(excludedList);
     return ((this.onExpressions as BinaryExpression[]) || [])
       .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+      .map((item) => item.name);
   }
   getBinaryExpressionUniqueName(name = 'binaryExpression1') {
     return utils.unique(name, this.getBinaryExpressionExistingNames(), undefined, false);
@@ -126,29 +138,23 @@ export class QueryJoinExpression extends LogicItem {
    * @internal
    * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
    */
-  _insertBinaryExpressionInOnExpressionsAt(name: string, index: number): BinaryExpression;
+  _insertBinaryExpressionAt(name: string, index: number): BinaryExpression;
 
   /**
    * 插入二元表达式
    * @internal
    * @param binaryExpressionOptions 二元表达式参数
    */
-  _insertBinaryExpressionInOnExpressionsAt(
-    binaryExpressionOptions: Partial<BinaryExpression>,
-    index: number,
-  ): BinaryExpression;
+  _insertBinaryExpressionAt(binaryExpressionOptions: Partial<BinaryExpression>, index: number): BinaryExpression;
 
   /**
    * 插入二元表达式
    * @internal
    * @param binaryExpression 已有的二元表达式实例
    */
-  _insertBinaryExpressionInOnExpressionsAt(binaryExpression: BinaryExpression, index: number): BinaryExpression;
+  _insertBinaryExpressionAt(binaryExpression: BinaryExpression, index: number): BinaryExpression;
 
-  _insertBinaryExpressionInOnExpressionsAt(
-    options: string | Partial<BinaryExpression> | BinaryExpression,
-    index: number,
-  ) {
+  _insertBinaryExpressionAt(options: string | Partial<BinaryExpression> | BinaryExpression, index: number) {
     const binaryExpressionOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'onExpressions' };
     const BinaryExpression = getConceptConstructor('BinaryExpression');
@@ -193,28 +199,22 @@ export class QueryJoinExpression extends LogicItem {
    * 插入二元表达式
    * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
    */
-  insertBinaryExpressionInOnExpressionsAt(name: string, index: number): BinaryExpression;
+  insertBinaryExpressionAt(name: string, index: number): BinaryExpression;
 
   /**
    * 插入二元表达式
    * @param binaryExpressionOptions 二元表达式参数
    */
-  insertBinaryExpressionInOnExpressionsAt(
-    binaryExpressionOptions: Partial<BinaryExpression>,
-    index: number,
-  ): BinaryExpression;
+  insertBinaryExpressionAt(binaryExpressionOptions: Partial<BinaryExpression>, index: number): BinaryExpression;
 
   /**
    * 插入二元表达式
    * @param binaryExpression 已有的二元表达式实例
    */
-  insertBinaryExpressionInOnExpressionsAt(binaryExpression: BinaryExpression, index: number): BinaryExpression;
+  insertBinaryExpressionAt(binaryExpression: BinaryExpression, index: number): BinaryExpression;
 
-  insertBinaryExpressionInOnExpressionsAt(
-    options: string | Partial<BinaryExpression> | BinaryExpression,
-    index: number,
-  ) {
-    const node = this._insertBinaryExpressionInOnExpressionsAt(options as any, index);
+  insertBinaryExpressionAt(options: string | Partial<BinaryExpression> | BinaryExpression, index: number) {
+    const node = this._insertBinaryExpressionAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -228,25 +228,25 @@ export class QueryJoinExpression extends LogicItem {
    * @internal
    * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
    */
-  _addBinaryExpressionInOnExpressions(name?: string): BinaryExpression;
+  _addBinaryExpression(name?: string): BinaryExpression;
 
   /**
    * 添加二元表达式
    * @internal
    * @param binaryExpressionOptions 二元表达式参数
    */
-  _addBinaryExpressionInOnExpressions(binaryExpressionOptions: Partial<BinaryExpression>): BinaryExpression;
+  _addBinaryExpression(binaryExpressionOptions: Partial<BinaryExpression>): BinaryExpression;
 
   /**
    * 添加二元表达式
    * @internal
    * @param binaryExpression 已有的二元表达式实例
    */
-  _addBinaryExpressionInOnExpressions(binaryExpression: BinaryExpression): BinaryExpression;
+  _addBinaryExpression(binaryExpression: BinaryExpression): BinaryExpression;
 
-  _addBinaryExpressionInOnExpressions(options?: string | Partial<BinaryExpression> | BinaryExpression) {
+  _addBinaryExpression(options?: string | Partial<BinaryExpression> | BinaryExpression) {
     const index = this.onExpressions.length;
-    return this._insertBinaryExpressionInOnExpressionsAt(options as any, index);
+    return this._insertBinaryExpressionAt(options as any, index);
   }
 
   /**
@@ -254,22 +254,22 @@ export class QueryJoinExpression extends LogicItem {
    * @internal
    * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
    */
-  addBinaryExpressionInOnExpressions(name?: string): BinaryExpression;
+  addBinaryExpression(name?: string): BinaryExpression;
 
   /**
    * 添加二元表达式
    * @param binaryExpressionOptions 二元表达式参数
    */
-  addBinaryExpressionInOnExpressions(binaryExpressionOptions: Partial<BinaryExpression>): BinaryExpression;
+  addBinaryExpression(binaryExpressionOptions: Partial<BinaryExpression>): BinaryExpression;
 
   /**
    * 添加二元表达式
    * @param binaryExpression 已有的二元表达式实例
    */
-  addBinaryExpressionInOnExpressions(binaryExpression: BinaryExpression): BinaryExpression;
+  addBinaryExpression(binaryExpression: BinaryExpression): BinaryExpression;
 
-  addBinaryExpressionInOnExpressions(options?: string | Partial<BinaryExpression> | BinaryExpression) {
-    const node = this._addBinaryExpressionInOnExpressions(options as any);
+  addBinaryExpression(options?: string | Partial<BinaryExpression> | BinaryExpression) {
+    const node = this._addBinaryExpression(options as any);
     const index = this.onExpressions.indexOf(node);
     node.create({
       index,
@@ -284,19 +284,16 @@ export class QueryJoinExpression extends LogicItem {
    * @internal
    * @param queryJoinExpressionOptions 查询 Join 子句参数
    */
-  _insertJoinPartInJoinPartsAt(
-    queryJoinExpressionOptions: Partial<QueryJoinExpression>,
-    index: number,
-  ): QueryJoinExpression;
+  _insertJoinPartAt(queryJoinExpressionOptions: Partial<QueryJoinExpression>, index: number): QueryJoinExpression;
 
   /**
    * 插入查询 Join 子句
    * @internal
    * @param queryJoinExpression 已有的查询 Join 子句实例
    */
-  _insertJoinPartInJoinPartsAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
+  _insertJoinPartAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
 
-  _insertJoinPartInJoinPartsAt(options: Partial<QueryJoinExpression> | QueryJoinExpression, index: number) {
+  _insertJoinPartAt(options: Partial<QueryJoinExpression> | QueryJoinExpression, index: number) {
     const queryJoinExpressionOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'joinParts' };
     const QueryJoinExpression = getConceptConstructor('QueryJoinExpression');
@@ -323,19 +320,16 @@ export class QueryJoinExpression extends LogicItem {
    * 插入查询 Join 子句
    * @param queryJoinExpressionOptions 查询 Join 子句参数
    */
-  insertJoinPartInJoinPartsAt(
-    queryJoinExpressionOptions: Partial<QueryJoinExpression>,
-    index: number,
-  ): QueryJoinExpression;
+  insertJoinPartAt(queryJoinExpressionOptions: Partial<QueryJoinExpression>, index: number): QueryJoinExpression;
 
   /**
    * 插入查询 Join 子句
    * @param queryJoinExpression 已有的查询 Join 子句实例
    */
-  insertJoinPartInJoinPartsAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
+  insertJoinPartAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
 
-  insertJoinPartInJoinPartsAt(options: Partial<QueryJoinExpression> | QueryJoinExpression, index: number) {
-    const node = this._insertJoinPartInJoinPartsAt(options as any, index);
+  insertJoinPartAt(options: Partial<QueryJoinExpression> | QueryJoinExpression, index: number) {
+    const node = this._insertJoinPartAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -349,34 +343,34 @@ export class QueryJoinExpression extends LogicItem {
    * @internal
    * @param queryJoinExpressionOptions 查询 Join 子句参数
    */
-  _addJoinPartInJoinParts(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
+  _addJoinPart(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
 
   /**
    * 添加查询 Join 子句
    * @internal
    * @param queryJoinExpression 已有的查询 Join 子句实例
    */
-  _addJoinPartInJoinParts(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
+  _addJoinPart(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
 
-  _addJoinPartInJoinParts(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
+  _addJoinPart(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
     const index = this.joinParts.length;
-    return this._insertJoinPartInJoinPartsAt(options as any, index);
+    return this._insertJoinPartAt(options as any, index);
   }
 
   /**
    * 添加查询 Join 子句
    * @param queryJoinExpressionOptions 查询 Join 子句参数
    */
-  addJoinPartInJoinParts(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
+  addJoinPart(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
 
   /**
    * 添加查询 Join 子句
    * @param queryJoinExpression 已有的查询 Join 子句实例
    */
-  addJoinPartInJoinParts(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
+  addJoinPart(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
 
-  addJoinPartInJoinParts(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
-    const node = this._addJoinPartInJoinParts(options as any);
+  addJoinPart(options?: Partial<QueryJoinExpression> | QueryJoinExpression) {
+    const node = this._addJoinPart(options as any);
     const index = this.joinParts.indexOf(node);
     node.create({
       index,
@@ -390,15 +384,15 @@ export class QueryJoinExpression extends LogicItem {
    * 删除二元表达式
    * @param name 二元表达式名称
    */
-  removeBinaryExpressionInOnExpressions(name: string): void;
+  removeBinaryExpression(name: string): void;
 
   /**
    * 删除二元表达式
    * @param binaryExpression 已有的二元表达式实例
    */
-  removeBinaryExpressionInOnExpressions(binaryExpression: BinaryExpression): void;
+  removeBinaryExpression(binaryExpression: BinaryExpression): void;
 
-  removeBinaryExpressionInOnExpressions(options: string | BinaryExpression) {
+  removeBinaryExpression(options: string | BinaryExpression) {
     let binaryExpression: BinaryExpression;
     if (typeof options === 'string') {
       binaryExpression = (this.onExpressions as BinaryExpression[]).find((item) => item.name === options);
@@ -415,44 +409,13 @@ export class QueryJoinExpression extends LogicItem {
    * 删除查询 Join 子句
    * @param queryJoinExpression 已有的查询 Join 子句实例
    */
-  removeJoinPartInJoinParts(queryJoinExpression: QueryJoinExpression): void;
+  removeJoinPart(queryJoinExpression: QueryJoinExpression): void;
 
-  removeJoinPartInJoinParts(options: QueryJoinExpression) {
+  removeJoinPart(options: QueryJoinExpression) {
     let queryJoinExpression: QueryJoinExpression = options;
     return queryJoinExpression.delete();
   }
 
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。

package/src/concepts/QueryLimitExpression__.ts

@@ -13,12 +13,13 @@ import {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
+
 import LogicItem from './LogicItem__';
 
 /**
@@ -28,7 +29,11 @@ import LogicItem from './LogicItem__';
 export class QueryLimitExpression extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'QueryLimitExpression';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
@@ -38,14 +43,13 @@ export class QueryLimitExpression extends LogicItem {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'QueryLimitExpression';
-
   /**
    * 逻辑项
    */
   @property({
     objectRef: 'LogicItem',
   })
-  pageElement!: LogicItem;
+  pageElement: LogicItem;
 
   /**
    * 逻辑项
@@ -53,7 +57,7 @@ export class QueryLimitExpression extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  pageSizeElement!: LogicItem;
+  pageSizeElement: LogicItem;
 
   /**
    * @param source 需要合并的部分参数
@@ -98,87 +102,6 @@ export class QueryLimitExpression extends LogicItem {
     });
   }
 
-  /**
-   * 删除逻辑项
-   * @param name 逻辑项名称
-   */
-  removePageElement(name: string): void;
-
-  /**
-   * 删除逻辑项
-   * @param pageElement 已有的逻辑项实例
-   */
-  removePageElement(pageElement: LogicItem): void;
-
-  removePageElement(options: string | LogicItem) {
-    let pageElement: LogicItem;
-    if (typeof options === 'string') {
-      pageElement = this.pageElement;
-      if (!pageElement) {
-        throw new Error('找不到逻辑项 ' + options);
-      }
-    } else {
-      pageElement = options;
-    }
-    return pageElement.delete();
-  }
-
-  /**
-   * 删除逻辑项
-   * @param name 逻辑项名称
-   */
-  removePageSizeElement(name: string): void;
-
-  /**
-   * 删除逻辑项
-   * @param pageSizeElement 已有的逻辑项实例
-   */
-  removePageSizeElement(pageSizeElement: LogicItem): void;
-
-  removePageSizeElement(options: string | LogicItem) {
-    let pageSizeElement: LogicItem;
-    if (typeof options === 'string') {
-      pageSizeElement = this.pageSizeElement;
-      if (!pageSizeElement) {
-        throw new Error('找不到逻辑项 ' + options);
-      }
-    } else {
-      pageSizeElement = options;
-    }
-    return pageSizeElement.delete();
-  }
-
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。

package/src/concepts/QueryOrderByExpression__.ts

@@ -14,12 +14,13 @@ import {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
+
 import LogicItem from './LogicItem__';
 
 /**
@@ -29,7 +30,11 @@ import LogicItem from './LogicItem__';
 export class QueryOrderByExpression extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'QueryOrderByExpression';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
@@ -39,14 +44,13 @@ export class QueryOrderByExpression extends LogicItem {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'QueryOrderByExpression';
-
   /**
    * 逻辑项
    */
   @property({
     objectRef: 'LogicItem',
   })
-  orderElement!: LogicItem;
+  orderElement: LogicItem;
 
   /**
    * 逻辑项
@@ -54,7 +58,7 @@ export class QueryOrderByExpression extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  order!: LogicItem;
+  order: LogicItem;
 
   /**
    * @param source 需要合并的部分参数
@@ -99,87 +103,6 @@ export class QueryOrderByExpression extends LogicItem {
     });
   }
 
-  /**
-   * 删除逻辑项
-   * @param name 逻辑项名称
-   */
-  removeOrderElement(name: string): void;
-
-  /**
-   * 删除逻辑项
-   * @param orderElement 已有的逻辑项实例
-   */
-  removeOrderElement(orderElement: LogicItem): void;
-
-  removeOrderElement(options: string | LogicItem) {
-    let orderElement: LogicItem;
-    if (typeof options === 'string') {
-      orderElement = this.orderElement;
-      if (!orderElement) {
-        throw new Error('找不到逻辑项 ' + options);
-      }
-    } else {
-      orderElement = options;
-    }
-    return orderElement.delete();
-  }
-
-  /**
-   * 删除逻辑项
-   * @param name 逻辑项名称
-   */
-  removeOrder(name: string): void;
-
-  /**
-   * 删除逻辑项
-   * @param order 已有的逻辑项实例
-   */
-  removeOrder(order: LogicItem): void;
-
-  removeOrder(options: string | LogicItem) {
-    let order: LogicItem;
-    if (typeof options === 'string') {
-      order = this.order;
-      if (!order) {
-        throw new Error('找不到逻辑项 ' + options);
-      }
-    } else {
-      order = options;
-    }
-    return order.delete();
-  }
-
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。