@aiao/rxdb-test 0.0.6 → 0.0.8

package/dist/entities/index.d.ts

@@ -1,4 +1,4 @@
-import { BooleanRules, CountOptions, DateRules, ENTITY_STATIC_TYPES, EntityBase, EntityType, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, FindTreeOptions, FindTreeRootOptions, IEntity, IEntityStaticType, ITreeEntity, KeyValueRules, NumberArrayRules, NumberRules, RelationBooleanRules, RelationDateRules, RelationEntitiesObservable, RelationEntityObservable, RelationNumberRules, RelationStringRules, RelationUUIDRules, RuleGroupBase, StringArrayRules, StringRules, TreeAdjacencyListEntityBase, UUID, UUIDRules } from '@aiao/rxdb';
+import { BooleanRules, CountOptions, DateRules, ENTITY_STATIC_TYPES, EntityBase, EntityType, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, FindTreeOptions, IEntity, ITreeEntity, KeyValueRules, NumberArrayRules, NumberRules, RelationBooleanRules, RelationDateRules, RelationEntitiesObservable, RelationEntityObservable, RelationExistsRules, RelationNumberRules, RelationStringRules, RelationUUIDRules, RuleGroupBase, StringArrayRules, StringRules, TreeAdjacencyListEntityBase, UUID, UUIDRules } from '@aiao/rxdb';
 import { Observable } from 'rxjs';
 
 /**
@@ -7,10 +7,8 @@ import { Observable } from 'rxjs';
 declare type TypeDemoRule = UUIDRules<TypeDemo, 'id'>
 | DateRules<TypeDemo, 'createdAt'>
 | DateRules<TypeDemo, 'updatedAt'>
-| DateRules<TypeDemo, 'removedAt'>
 | StringRules<TypeDemo, 'createdBy'>
 | StringRules<TypeDemo, 'updatedBy'>
-| StringRules<TypeDemo, 'removedBy'>
 | StringRules<TypeDemo, 'string'>
 | NumberRules<TypeDemo, 'number'>
 | NumberRules<TypeDemo, 'integer'>
@@ -28,14 +26,12 @@ declare type TypeDemoRule = UUIDRules<TypeDemo, 'id'>
 /**
  * RuleGroupBase
  */
-export declare type TypeDemoRuleGroup = RuleGroupBase<typeof TypeDemo, 
+export declare type TypeDemoRuleGroup = RuleGroupBase<typeof TypeDemo,
   |'id'
   |'createdAt'
   |'updatedAt'
-  |'removedAt'
   |'createdBy'
   |'updatedBy'
-  |'removedBy'
   |'string'
   |'number'
   |'integer'
@@ -54,7 +50,7 @@ TypeDemoRule>;
 /**
  * OrderByField
  */
-declare type TypeDemoOrderByField = "id" | "createdAt" | "updatedAt" | "removedAt" | "createdBy" | "updatedBy" | "removedBy" | "string" | "number" | "integer" | "boolean" | "date" | "stringArray" | "numberArray" | "keyValue" | "json";
+declare type TypeDemoOrderByField = "id" | "createdAt" | "updatedAt" | "createdBy" | "updatedBy" | "string" | "number" | "integer" | "boolean" | "date" | "stringArray" | "numberArray" | "keyValue" | "json";
 
 /**
  * rule
@@ -62,24 +58,20 @@ declare type TypeDemoOrderByField = "id" | "createdAt" | "updatedAt" | "removedA
 declare type TodoRule = UUIDRules<Todo, 'id'>
 | DateRules<Todo, 'createdAt'>
 | DateRules<Todo, 'updatedAt'>
-| DateRules<Todo, 'removedAt'>
 | StringRules<Todo, 'createdBy'>
 | StringRules<Todo, 'updatedBy'>
-| StringRules<Todo, 'removedBy'>
 | StringRules<Todo, 'title'>
 | BooleanRules<Todo, 'completed'>;
 
 /**
  * RuleGroupBase
  */
-export declare type TodoRuleGroup = RuleGroupBase<typeof Todo, 
+export declare type TodoRuleGroup = RuleGroupBase<typeof Todo,
   |'id'
   |'createdAt'
   |'updatedAt'
-  |'removedAt'
   |'createdBy'
   |'updatedBy'
-  |'removedBy'
   |'title'
   |'completed',
 TodoRule>;
@@ -87,90 +79,369 @@ TodoRule>;
 /**
  * OrderByField
  */
-declare type TodoOrderByField = "id" | "createdAt" | "updatedAt" | "removedAt" | "createdBy" | "updatedBy" | "removedBy" | "title" | "completed";
+declare type TodoOrderByField = "id" | "createdAt" | "updatedAt" | "createdBy" | "updatedBy" | "title" | "completed";
 
 /**
  * rule
  */
-declare type MenuRule = UUIDRules<Menu, 'id'>
-| DateRules<Menu, 'createdAt'>
-| DateRules<Menu, 'updatedAt'>
-| DateRules<Menu, 'removedAt'>
-| StringRules<Menu, 'createdBy'>
-| StringRules<Menu, 'updatedBy'>
-| StringRules<Menu, 'removedBy'>
-| StringRules<Menu, 'title'>
-| UUIDRules<Menu, 'parentId'>
+declare type MenuSimpleRule = UUIDRules<MenuSimple, 'id'>
+| DateRules<MenuSimple, 'createdAt'>
+| DateRules<MenuSimple, 'updatedAt'>
+| StringRules<MenuSimple, 'createdBy'>
+| StringRules<MenuSimple, 'updatedBy'>
+| StringRules<MenuSimple, 'title'>
+| StringRules<MenuSimple, 'sortOrder'>
+| UUIDRules<MenuSimple, 'parentId'>
+| RelationExistsRules<'children', MenuSimpleRuleGroup>
 | RelationUUIDRules<'children.id', UUID>
 | RelationDateRules<'children.createdAt', Date>
 | RelationDateRules<'children.updatedAt', Date>
-| RelationDateRules<'children.removedAt', Date | null>
 | RelationStringRules<'children.createdBy', string | null>
 | RelationStringRules<'children.updatedBy', string | null>
-| RelationStringRules<'children.removedBy', string | null>
 | RelationStringRules<'children.title', string>
+| RelationStringRules<'children.sortOrder', string | null>
+| RelationExistsRules<'parent', MenuSimpleRuleGroup>
 | RelationUUIDRules<'parent.id', UUID>
 | RelationDateRules<'parent.createdAt', Date>
 | RelationDateRules<'parent.updatedAt', Date>
-| RelationDateRules<'parent.removedAt', Date | null>
 | RelationStringRules<'parent.createdBy', string | null>
 | RelationStringRules<'parent.updatedBy', string | null>
-| RelationStringRules<'parent.removedBy', string | null>
-| RelationStringRules<'parent.title', string>;
+| RelationStringRules<'parent.title', string>
+| RelationStringRules<'parent.sortOrder', string | null>;
 
 /**
  * RuleGroupBase
  */
-export declare type MenuRuleGroup = RuleGroupBase<typeof Menu, 
+export declare type MenuSimpleRuleGroup = RuleGroupBase<typeof MenuSimple,
   |'id'
   |'createdAt'
   |'updatedAt'
-  |'removedAt'
   |'createdBy'
   |'updatedBy'
-  |'removedBy'
   |'title'
+  |'sortOrder'
   |'parentId'
+  |'children'
   |'children.id'
   |'children.createdAt'
   |'children.updatedAt'
-  |'children.removedAt'
   |'children.createdBy'
   |'children.updatedBy'
-  |'children.removedBy'
   |'children.title'
+  |'children.sortOrder'
   |'parentId'
+  |'parent'
   |'parent.id'
   |'parent.createdAt'
   |'parent.updatedAt'
-  |'parent.removedAt'
   |'parent.createdBy'
   |'parent.updatedBy'
-  |'parent.removedBy'
   |'parent.title'
+  |'parent.sortOrder'
   |'parentId',
-MenuRule>;
+MenuSimpleRule>;
 
 /**
  * OrderByField
  */
-declare type MenuOrderByField = "id" | "createdAt" | "updatedAt" | "removedAt" | "createdBy" | "updatedBy" | "removedBy" | "title";
+declare type MenuSimpleOrderByField = "id" | "createdAt" | "updatedAt" | "createdBy" | "updatedBy" | "title" | "sortOrder";
 
 /**
  * TreeRule
  */
-declare type MenuTreeRule = RelationDateRules<'children.createdAt', Date>
+declare type MenuSimpleTreeRule = RelationDateRules<'children.createdAt', Date>
 | RelationDateRules<'children.updatedAt', Date>
-| RelationDateRules<'children.removedAt', Date | null>
 | RelationStringRules<'children.createdBy', string | null>
 | RelationStringRules<'children.updatedBy', string | null>
-| RelationStringRules<'children.removedBy', string | null>
-| RelationStringRules<'children.title', string>;
+| RelationStringRules<'children.title', string>
+| RelationStringRules<'children.sortOrder', string | null>;
+
+/**
+ * TreeRuleGroup
+ */
+export declare type MenuSimpleTreeRuleGroup = RuleGroupBase<typeof MenuSimple, 'children.createdAt' | 'children.updatedAt' | 'children.createdBy' | 'children.updatedBy' | 'children.title' | 'children.sortOrder', MenuSimpleTreeRule>;
+
+/**
+ * rule
+ */
+declare type MenuLargeRule = UUIDRules<MenuLarge, 'id'>
+| DateRules<MenuLarge, 'createdAt'>
+| DateRules<MenuLarge, 'updatedAt'>
+| StringRules<MenuLarge, 'createdBy'>
+| StringRules<MenuLarge, 'updatedBy'>
+| StringRules<MenuLarge, 'title'>
+| StringRules<MenuLarge, 'sortOrder'>
+| UUIDRules<MenuLarge, 'parentId'>
+| RelationExistsRules<'children', MenuLargeRuleGroup>
+| RelationUUIDRules<'children.id', UUID>
+| RelationDateRules<'children.createdAt', Date>
+| RelationDateRules<'children.updatedAt', Date>
+| RelationStringRules<'children.createdBy', string | null>
+| RelationStringRules<'children.updatedBy', string | null>
+| RelationStringRules<'children.title', string>
+| RelationStringRules<'children.sortOrder', string | null>
+| RelationExistsRules<'parent', MenuLargeRuleGroup>
+| RelationUUIDRules<'parent.id', UUID>
+| RelationDateRules<'parent.createdAt', Date>
+| RelationDateRules<'parent.updatedAt', Date>
+| RelationStringRules<'parent.createdBy', string | null>
+| RelationStringRules<'parent.updatedBy', string | null>
+| RelationStringRules<'parent.title', string>
+| RelationStringRules<'parent.sortOrder', string | null>;
+
+/**
+ * RuleGroupBase
+ */
+export declare type MenuLargeRuleGroup = RuleGroupBase<typeof MenuLarge,
+  |'id'
+  |'createdAt'
+  |'updatedAt'
+  |'createdBy'
+  |'updatedBy'
+  |'title'
+  |'sortOrder'
+  |'parentId'
+  |'children'
+  |'children.id'
+  |'children.createdAt'
+  |'children.updatedAt'
+  |'children.createdBy'
+  |'children.updatedBy'
+  |'children.title'
+  |'children.sortOrder'
+  |'parentId'
+  |'parent'
+  |'parent.id'
+  |'parent.createdAt'
+  |'parent.updatedAt'
+  |'parent.createdBy'
+  |'parent.updatedBy'
+  |'parent.title'
+  |'parent.sortOrder'
+  |'parentId',
+MenuLargeRule>;
+
+/**
+ * OrderByField
+ */
+declare type MenuLargeOrderByField = "id" | "createdAt" | "updatedAt" | "createdBy" | "updatedBy" | "title" | "sortOrder";
+
+/**
+ * TreeRule
+ */
+declare type MenuLargeTreeRule = RelationDateRules<'children.createdAt', Date>
+| RelationDateRules<'children.updatedAt', Date>
+| RelationStringRules<'children.createdBy', string | null>
+| RelationStringRules<'children.updatedBy', string | null>
+| RelationStringRules<'children.title', string>
+| RelationStringRules<'children.sortOrder', string | null>;
 
 /**
  * TreeRuleGroup
  */
-export declare type MenuTreeRuleGroup = RuleGroupBase<typeof Menu, 'children.createdAt' | 'children.updatedAt' | 'children.removedAt' | 'children.createdBy' | 'children.updatedBy' | 'children.removedBy' | 'children.title', MenuTreeRule>;
+export declare type MenuLargeTreeRuleGroup = RuleGroupBase<typeof MenuLarge, 'children.createdAt' | 'children.updatedAt' | 'children.createdBy' | 'children.updatedBy' | 'children.title' | 'children.sortOrder', MenuLargeTreeRule>;
+
+/**
+ * rule
+ */
+declare type FileNodeRule = UUIDRules<FileNode, 'id'>
+| DateRules<FileNode, 'createdAt'>
+| DateRules<FileNode, 'updatedAt'>
+| StringRules<FileNode, 'createdBy'>
+| StringRules<FileNode, 'updatedBy'>
+| StringRules<FileNode, 'name'>
+| StringRules<FileNode, 'type'>
+| StringRules<FileNode, 'sortOrder'>
+| StringRules<FileNode, 'extension'>
+| NumberRules<FileNode, 'size'>
+| UUIDRules<FileNode, 'parentId'>
+| RelationExistsRules<'children', FileNodeRuleGroup>
+| RelationUUIDRules<'children.id', UUID>
+| RelationDateRules<'children.createdAt', Date>
+| RelationDateRules<'children.updatedAt', Date>
+| RelationStringRules<'children.createdBy', string | null>
+| RelationStringRules<'children.updatedBy', string | null>
+| RelationStringRules<'children.name', string>
+| RelationStringRules<'children.type', string>
+| RelationStringRules<'children.sortOrder', string | null>
+| RelationStringRules<'children.extension', string | null>
+| RelationNumberRules<'children.size', number | null>
+| RelationExistsRules<'parent', FileNodeRuleGroup>
+| RelationUUIDRules<'parent.id', UUID>
+| RelationDateRules<'parent.createdAt', Date>
+| RelationDateRules<'parent.updatedAt', Date>
+| RelationStringRules<'parent.createdBy', string | null>
+| RelationStringRules<'parent.updatedBy', string | null>
+| RelationStringRules<'parent.name', string>
+| RelationStringRules<'parent.type', string>
+| RelationStringRules<'parent.sortOrder', string | null>
+| RelationStringRules<'parent.extension', string | null>
+| RelationNumberRules<'parent.size', number | null>;
+
+/**
+ * RuleGroupBase
+ */
+export declare type FileNodeRuleGroup = RuleGroupBase<typeof FileNode,
+  |'id'
+  |'createdAt'
+  |'updatedAt'
+  |'createdBy'
+  |'updatedBy'
+  |'name'
+  |'type'
+  |'sortOrder'
+  |'extension'
+  |'size'
+  |'parentId'
+  |'children'
+  |'children.id'
+  |'children.createdAt'
+  |'children.updatedAt'
+  |'children.createdBy'
+  |'children.updatedBy'
+  |'children.name'
+  |'children.type'
+  |'children.sortOrder'
+  |'children.extension'
+  |'children.size'
+  |'parentId'
+  |'parent'
+  |'parent.id'
+  |'parent.createdAt'
+  |'parent.updatedAt'
+  |'parent.createdBy'
+  |'parent.updatedBy'
+  |'parent.name'
+  |'parent.type'
+  |'parent.sortOrder'
+  |'parent.extension'
+  |'parent.size'
+  |'parentId',
+FileNodeRule>;
+
+/**
+ * OrderByField
+ */
+declare type FileNodeOrderByField = "id" | "createdAt" | "updatedAt" | "createdBy" | "updatedBy" | "name" | "type" | "sortOrder" | "extension" | "size";
+
+/**
+ * TreeRule
+ */
+declare type FileNodeTreeRule = RelationDateRules<'children.createdAt', Date>
+| RelationDateRules<'children.updatedAt', Date>
+| RelationStringRules<'children.createdBy', string | null>
+| RelationStringRules<'children.updatedBy', string | null>
+| RelationStringRules<'children.name', string>
+| RelationStringRules<'children.type', string>
+| RelationStringRules<'children.sortOrder', string | null>
+| RelationStringRules<'children.extension', string | null>
+| RelationNumberRules<'children.size', number | null>;
+
+/**
+ * TreeRuleGroup
+ */
+export declare type FileNodeTreeRuleGroup = RuleGroupBase<typeof FileNode, 'children.createdAt' | 'children.updatedAt' | 'children.createdBy' | 'children.updatedBy' | 'children.name' | 'children.type' | 'children.sortOrder' | 'children.extension' | 'children.size', FileNodeTreeRule>;
+
+/**
+ * rule
+ */
+declare type FileLargeRule = UUIDRules<FileLarge, 'id'>
+| DateRules<FileLarge, 'createdAt'>
+| DateRules<FileLarge, 'updatedAt'>
+| StringRules<FileLarge, 'createdBy'>
+| StringRules<FileLarge, 'updatedBy'>
+| StringRules<FileLarge, 'name'>
+| StringRules<FileLarge, 'type'>
+| StringRules<FileLarge, 'sortOrder'>
+| StringRules<FileLarge, 'extension'>
+| NumberRules<FileLarge, 'size'>
+| UUIDRules<FileLarge, 'parentId'>
+| RelationExistsRules<'children', FileLargeRuleGroup>
+| RelationUUIDRules<'children.id', UUID>
+| RelationDateRules<'children.createdAt', Date>
+| RelationDateRules<'children.updatedAt', Date>
+| RelationStringRules<'children.createdBy', string | null>
+| RelationStringRules<'children.updatedBy', string | null>
+| RelationStringRules<'children.name', string>
+| RelationStringRules<'children.type', string>
+| RelationStringRules<'children.sortOrder', string | null>
+| RelationStringRules<'children.extension', string | null>
+| RelationNumberRules<'children.size', number | null>
+| RelationExistsRules<'parent', FileLargeRuleGroup>
+| RelationUUIDRules<'parent.id', UUID>
+| RelationDateRules<'parent.createdAt', Date>
+| RelationDateRules<'parent.updatedAt', Date>
+| RelationStringRules<'parent.createdBy', string | null>
+| RelationStringRules<'parent.updatedBy', string | null>
+| RelationStringRules<'parent.name', string>
+| RelationStringRules<'parent.type', string>
+| RelationStringRules<'parent.sortOrder', string | null>
+| RelationStringRules<'parent.extension', string | null>
+| RelationNumberRules<'parent.size', number | null>;
+
+/**
+ * RuleGroupBase
+ */
+export declare type FileLargeRuleGroup = RuleGroupBase<typeof FileLarge,
+  |'id'
+  |'createdAt'
+  |'updatedAt'
+  |'createdBy'
+  |'updatedBy'
+  |'name'
+  |'type'
+  |'sortOrder'
+  |'extension'
+  |'size'
+  |'parentId'
+  |'children'
+  |'children.id'
+  |'children.createdAt'
+  |'children.updatedAt'
+  |'children.createdBy'
+  |'children.updatedBy'
+  |'children.name'
+  |'children.type'
+  |'children.sortOrder'
+  |'children.extension'
+  |'children.size'
+  |'parentId'
+  |'parent'
+  |'parent.id'
+  |'parent.createdAt'
+  |'parent.updatedAt'
+  |'parent.createdBy'
+  |'parent.updatedBy'
+  |'parent.name'
+  |'parent.type'
+  |'parent.sortOrder'
+  |'parent.extension'
+  |'parent.size'
+  |'parentId',
+FileLargeRule>;
+
+/**
+ * OrderByField
+ */
+declare type FileLargeOrderByField = "id" | "createdAt" | "updatedAt" | "createdBy" | "updatedBy" | "name" | "type" | "sortOrder" | "extension" | "size";
+
+/**
+ * TreeRule
+ */
+declare type FileLargeTreeRule = RelationDateRules<'children.createdAt', Date>
+| RelationDateRules<'children.updatedAt', Date>
+| RelationStringRules<'children.createdBy', string | null>
+| RelationStringRules<'children.updatedBy', string | null>
+| RelationStringRules<'children.name', string>
+| RelationStringRules<'children.type', string>
+| RelationStringRules<'children.sortOrder', string | null>
+| RelationStringRules<'children.extension', string | null>
+| RelationNumberRules<'children.size', number | null>;
+
+/**
+ * TreeRuleGroup
+ */
+export declare type FileLargeTreeRuleGroup = RuleGroupBase<typeof FileLarge, 'children.createdAt' | 'children.updatedAt' | 'children.createdBy' | 'children.updatedBy' | 'children.name' | 'children.type' | 'children.sortOrder' | 'children.extension' | 'children.size', FileLargeTreeRule>;
 
 /**
  * rxdb
@@ -189,9 +460,21 @@ declare module "@aiao/rxdb" {
      */
     Todo: typeof Todo;
     /**
-     * Menu
+     * MenuSimple
+     */
+    MenuSimple: typeof MenuSimple;
+    /**
+     * MenuLarge
      */
-    Menu: typeof Menu;
+    MenuLarge: typeof MenuLarge;
+    /**
+     * FileNode
+     */
+    FileNode: typeof FileNode;
+    /**
+     * FileLarge
+     */
+    FileLarge: typeof FileLarge;
   }
 }
 
@@ -291,57 +574,285 @@ export interface TypeDemoKeyValueKeyValue {
  */
 export interface TodoStaticTypes {
   /**
-   * id 类型
+   * id 类型
+   */
+  idType: UUID;
+  /**
+   * 查询选项
+   */
+  getOptions: UUID;
+  /**
+   * 查询选项
+   */
+  findOneOrFailOptions: FindOneOrFailOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  /**
+   * 查询选项
+   */
+  findOptions: FindOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  /**
+   * 查询选项
+   */
+  findOneOptions: FindOneOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  /**
+   * 查询选项
+   */
+  findAllOptions: FindAllOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  /**
+   * 查询选项
+   */
+  findByCursorOptions: FindByCursorOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  /**
+   * 查询选项
+   */
+  countOptions: CountOptions<typeof Todo,TodoRuleGroup>;
+}
+
+/**
+ * 初始化数据
+ */
+export interface TodoInitData {
+  /**
+   * title
+   */
+  title?: string;
+  /**
+   * completed
+   */
+  completed?: boolean;
+}
+
+/**
+ * 静态类型
+ */
+export interface MenuSimpleStaticTypes {
+  /**
+   * id 类型
+   */
+  idType: UUID;
+  /**
+   * 查询选项
+   */
+  getOptions: UUID;
+  /**
+   * 查询选项
+   */
+  findOneOrFailOptions: FindOneOrFailOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>;
+  /**
+   * 查询选项
+   */
+  findOptions: FindOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>;
+  /**
+   * 查询选项
+   */
+  findOneOptions: FindOneOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>;
+  /**
+   * 查询选项
+   */
+  findAllOptions: FindAllOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>;
+  /**
+   * 查询选项
+   */
+  findByCursorOptions: FindByCursorOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>;
+  /**
+   * 查询选项
+   */
+  countOptions: CountOptions<typeof MenuSimple,MenuSimpleRuleGroup>;
+  /**
+   * 查询的实体
+   */
+  entity: MenuSimple;
+  /**
+   * 查询选项
+   */
+  findDescendantsOptions: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>;
+  /**
+   * 查询选项
+   */
+  countDescendantsOptions: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>;
+  /**
+   * 查询选项
+   */
+  findAncestorsOptions: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>;
+  /**
+   * 查询选项
+   */
+  countAncestorsOptions: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>;
+}
+
+/**
+ * 初始化数据
+ */
+export interface MenuSimpleInitData {
+  /**
+   * title
+   */
+  title?: string;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
+}
+
+/**
+ * 静态类型
+ */
+export interface MenuLargeStaticTypes {
+  /**
+   * id 类型
+   */
+  idType: UUID;
+  /**
+   * 查询选项
+   */
+  getOptions: UUID;
+  /**
+   * 查询选项
+   */
+  findOneOrFailOptions: FindOneOrFailOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>;
+  /**
+   * 查询选项
+   */
+  findOptions: FindOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>;
+  /**
+   * 查询选项
+   */
+  findOneOptions: FindOneOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>;
+  /**
+   * 查询选项
+   */
+  findAllOptions: FindAllOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>;
+  /**
+   * 查询选项
+   */
+  findByCursorOptions: FindByCursorOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>;
+  /**
+   * 查询选项
+   */
+  countOptions: CountOptions<typeof MenuLarge,MenuLargeRuleGroup>;
+  /**
+   * 查询的实体
+   */
+  entity: MenuLarge;
+  /**
+   * 查询选项
+   */
+  findDescendantsOptions: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>;
+  /**
+   * 查询选项
+   */
+  countDescendantsOptions: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>;
+  /**
+   * 查询选项
+   */
+  findAncestorsOptions: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>;
+  /**
+   * 查询选项
+   */
+  countAncestorsOptions: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>;
+}
+
+/**
+ * 初始化数据
+ */
+export interface MenuLargeInitData {
+  /**
+   * title
+   */
+  title?: string;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
+}
+
+/**
+ * 静态类型
+ */
+export interface FileNodeStaticTypes {
+  /**
+   * id 类型
+   */
+  idType: UUID;
+  /**
+   * 查询选项
+   */
+  getOptions: UUID;
+  /**
+   * 查询选项
+   */
+  findOneOrFailOptions: FindOneOrFailOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>;
+  /**
+   * 查询选项
+   */
+  findOptions: FindOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>;
+  /**
+   * 查询选项
    */
-  idType: UUID;
+  findOneOptions: FindOneOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>;
   /**
    * 查询选项
    */
-  getOptions: UUID;
+  findAllOptions: FindAllOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>;
   /**
    * 查询选项
    */
-  findOneOrFailOptions: FindOneOrFailOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  findByCursorOptions: FindByCursorOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>;
   /**
    * 查询选项
    */
-  findOptions: FindOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  countOptions: CountOptions<typeof FileNode,FileNodeRuleGroup>;
+  /**
+   * 查询的实体
+   */
+  entity: FileNode;
   /**
    * 查询选项
    */
-  findOneOptions: FindOneOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  findDescendantsOptions: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>;
   /**
    * 查询选项
    */
-  findAllOptions: FindAllOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  countDescendantsOptions: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>;
   /**
    * 查询选项
    */
-  findByCursorOptions: FindByCursorOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>;
+  findAncestorsOptions: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>;
   /**
    * 查询选项
    */
-  countOptions: CountOptions<typeof Todo,TodoRuleGroup>;
+  countAncestorsOptions: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>;
 }
 
 /**
  * 初始化数据
  */
-export interface TodoInitData {
+export interface FileNodeInitData {
   /**
-   * title
+   * name
    */
-  title?: string;
+  name?: string;
   /**
-   * completed
+   * type
    */
-  completed?: boolean;
+  type?: string;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
+  /**
+   * extension
+   */
+  extension?: string | null;
+  /**
+   * size
+   */
+  size?: number | null;
 }
 
 /**
  * 静态类型
  */
-export interface MenuStaticTypes {
+export interface FileLargeStaticTypes {
   /**
    * id 类型
    */
@@ -353,63 +864,79 @@ export interface MenuStaticTypes {
   /**
    * 查询选项
    */
-  findOneOrFailOptions: FindOneOrFailOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>;
+  findOneOrFailOptions: FindOneOrFailOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>;
   /**
    * 查询选项
    */
-  findOptions: FindOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>;
+  findOptions: FindOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>;
   /**
    * 查询选项
    */
-  findOneOptions: FindOneOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>;
+  findOneOptions: FindOneOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>;
   /**
    * 查询选项
    */
-  findAllOptions: FindAllOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>;
+  findAllOptions: FindAllOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>;
   /**
    * 查询选项
    */
-  findByCursorOptions: FindByCursorOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>;
+  findByCursorOptions: FindByCursorOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>;
   /**
    * 查询选项
    */
-  countOptions: CountOptions<typeof Menu,MenuRuleGroup>;
+  countOptions: CountOptions<typeof FileLarge,FileLargeRuleGroup>;
   /**
    * 查询的实体
    */
-  entity: Menu;
+  entity: FileLarge;
   /**
    * 查询选项
    */
-  findDescendantsOptions: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>;
+  findDescendantsOptions: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>;
   /**
    * 查询选项
    */
-  countDescendantsOptions: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>;
+  countDescendantsOptions: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>;
   /**
    * 查询选项
    */
-  findAncestorsOptions: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>;
+  findAncestorsOptions: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>;
   /**
    * 查询选项
    */
-  countAncestorsOptions: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>;
+  countAncestorsOptions: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>;
 }
 
 /**
  * 初始化数据
  */
-export interface MenuInitData {
+export interface FileLargeInitData {
   /**
-   * title
+   * name
    */
-  title?: string;
+  name?: string;
+  /**
+   * type
+   */
+  type?: string;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
+  /**
+   * extension
+   */
+  extension?: string | null;
+  /**
+   * size
+   */
+  size?: number | null;
 }
 
 /**
  * TypeDemo
  */
-export declare class TypeDemo extends EntityBase implements IEntity, IEntityStaticType {
+export declare class TypeDemo extends EntityBase implements IEntity {
   static [ENTITY_STATIC_TYPES]: TypeDemoStaticTypes;
   /**
    * boolean
@@ -453,38 +980,52 @@ export declare class TypeDemo extends EntityBase implements IEntity, IEntityStat
    */
   constructor(initData?: TypeDemoInitData);
   /**
-   * count 查询
+   * 统计实体数量
    * @param options 查询选项
+   * @example
+   * TypeDemo.count({ where: { combinator: 'and', rules: [] } }).subscribe(total => console.log(total));
    */
   static count(options: CountOptions<typeof TypeDemo,TypeDemoRuleGroup>): Observable<number>;
   /**
-   * find 查询
+   * 查询多个实体
    * @param options 查询选项
+   * @example
+   * TypeDemo.find({ where: { combinator: 'and', rules: [] }] }).subscribe(list => console.log(list));
    */
   static find(options: FindOptions<typeof TypeDemo,TypeDemoRuleGroup,TypeDemoOrderByField>): Observable<TypeDemo[]>;
   /**
-   * findAll 查询
+   * 查询所有实体
    * @param options 查询选项
+   * @example
+   * TypeDemo.findAll({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
    */
   static findAll(options: FindAllOptions<typeof TypeDemo,TypeDemoRuleGroup,TypeDemoOrderByField>): Observable<TypeDemo[]>;
   /**
-   * findByCursor 查询
+   * 游标分页查询
    * @param options 查询选项
+   * @example
+   * TypeDemo.findByCursor({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
    */
   static findByCursor(options: FindByCursorOptions<typeof TypeDemo,TypeDemoRuleGroup,TypeDemoOrderByField>): Observable<TypeDemo[]>;
   /**
-   * findOne 查询
+   * 查询单个实体,未找到时返回 undefined
    * @param options 查询选项
+   * @example
+   * TypeDemo.findOne({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
    */
   static findOne(options: FindOneOptions<typeof TypeDemo,TypeDemoRuleGroup,TypeDemoOrderByField>): Observable<TypeDemo | undefined>;
   /**
-   * findOneOrFail 查询
+   * 查询单个实体,未找到时抛出错误
    * @param options 查询选项
+   * @example
+   * TypeDemo.findOneOrFail({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
    */
   static findOneOrFail(options: FindOneOrFailOptions<typeof TypeDemo,TypeDemoRuleGroup,TypeDemoOrderByField>): Observable<TypeDemo>;
   /**
-   * get 查询
+   * 根据 ID 获取单个实体
    * @param options 查询选项
+   * @example
+   * TypeDemo.get('123').subscribe(entity => console.log(entity));
    */
   static get(options: UUID): Observable<TypeDemo>;
   /**
@@ -504,7 +1045,7 @@ export declare class TypeDemo extends EntityBase implements IEntity, IEntityStat
 /**
  * Todo
  */
-export declare class Todo extends EntityBase implements IEntity, IEntityStaticType {
+export declare class Todo extends EntityBase implements IEntity {
   static [ENTITY_STATIC_TYPES]: TodoStaticTypes;
   /**
    * completed
@@ -520,38 +1061,52 @@ export declare class Todo extends EntityBase implements IEntity, IEntityStaticTy
    */
   constructor(initData?: TodoInitData);
   /**
-   * count 查询
+   * 统计实体数量
    * @param options 查询选项
+   * @example
+   * Todo.count({ where: { combinator: 'and', rules: [] } }).subscribe(total => console.log(total));
    */
   static count(options: CountOptions<typeof Todo,TodoRuleGroup>): Observable<number>;
   /**
-   * find 查询
+   * 查询多个实体
    * @param options 查询选项
+   * @example
+   * Todo.find({ where: { combinator: 'and', rules: [] }] }).subscribe(list => console.log(list));
    */
   static find(options: FindOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>): Observable<Todo[]>;
   /**
-   * findAll 查询
+   * 查询所有实体
    * @param options 查询选项
+   * @example
+   * Todo.findAll({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
    */
   static findAll(options: FindAllOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>): Observable<Todo[]>;
   /**
-   * findByCursor 查询
+   * 游标分页查询
    * @param options 查询选项
+   * @example
+   * Todo.findByCursor({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
    */
   static findByCursor(options: FindByCursorOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>): Observable<Todo[]>;
   /**
-   * findOne 查询
+   * 查询单个实体,未找到时返回 undefined
    * @param options 查询选项
+   * @example
+   * Todo.findOne({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
    */
   static findOne(options: FindOneOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>): Observable<Todo | undefined>;
   /**
-   * findOneOrFail 查询
+   * 查询单个实体,未找到时抛出错误
    * @param options 查询选项
+   * @example
+   * Todo.findOneOrFail({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
    */
   static findOneOrFail(options: FindOneOrFailOptions<typeof Todo,TodoRuleGroup,TodoOrderByField>): Observable<Todo>;
   /**
-   * get 查询
+   * 根据 ID 获取单个实体
    * @param options 查询选项
+   * @example
+   * Todo.get('123').subscribe(entity => console.log(entity));
    */
   static get(options: UUID): Observable<Todo>;
   /**
@@ -569,22 +1124,161 @@ export declare class Todo extends EntityBase implements IEntity, IEntityStaticTy
 }
 
 /**
- * Menu
+ * MenuSimple
+ */
+export declare class MenuSimple extends TreeAdjacencyListEntityBase implements ITreeEntity {
+  static [ENTITY_STATIC_TYPES]: MenuSimpleStaticTypes;
+  /**
+   * children
+   */
+  readonly children$: RelationEntitiesObservable<MenuSimple>;
+  /**
+   * parent
+   */
+  readonly parent$: RelationEntityObservable<typeof MenuSimple>;
+  /**
+   * parent id
+   */
+  parentId?: UUID | null;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
+  /**
+   * title
+   */
+  title: string;
+  /**
+   * 初始化数据
+   * @param initData 初始化数据
+   */
+  constructor(initData?: MenuSimpleInitData);
+  /**
+   * 统计实体数量
+   * @param options 查询选项
+   * @example
+   * MenuSimple.count({ where: { combinator: 'and', rules: [] } }).subscribe(total => console.log(total));
+   */
+  static count(options: CountOptions<typeof MenuSimple,MenuSimpleRuleGroup>): Observable<number>;
+  /**
+   * 统计祖先实体数量（不包含自身）
+   * @param options 查询选项
+   * @example
+   * // 统计某节点的祖先层级深度
+MenuSimple.countAncestors({ entityId: grand.id }).subscribe(depth => console.log(depth));
+   */
+  static countAncestors(options?: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>): Observable<number>;
+  /**
+   * 统计子孙实体数量（不包含自身）
+   * @param options 查询选项
+   * @example
+   * // 统计某节点下的后代数量
+MenuSimple.countDescendants({ entityId: root.id }).subscribe(count => console.log(count));
+   */
+  static countDescendants(options?: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>): Observable<number>;
+  /**
+   * 查询多个实体
+   * @param options 查询选项
+   * @example
+   * MenuSimple.find({ where: { combinator: 'and', rules: [] }] }).subscribe(list => console.log(list));
+   */
+  static find(options: FindOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>): Observable<MenuSimple[]>;
+  /**
+   * 查询所有实体
+   * @param options 查询选项
+   * @example
+   * MenuSimple.findAll({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
+   */
+  static findAll(options: FindAllOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>): Observable<MenuSimple[]>;
+  /**
+   * 查询祖先实体（包含自身）
+   * @param options 查询选项
+   * @example
+   * // 查询某节点的所有祖先（面包屑导航）
+MenuSimple.findAncestors({ entityId: grand.id }).subscribe(ancestors => console.log(ancestors));
+
+// 仅查询直接父节点（level 1）
+MenuSimple.findAncestors({ entityId: grand.id, level: 1 }).subscribe(parents => console.log(parents));
+   */
+  static findAncestors(options?: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>): Observable<MenuSimple[]>;
+  /**
+   * 游标分页查询
+   * @param options 查询选项
+   * @example
+   * MenuSimple.findByCursor({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
+   */
+  static findByCursor(options: FindByCursorOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>): Observable<MenuSimple[]>;
+  /**
+   * 查询子孙实体（包含自身）
+   * @param options 查询选项
+   * @example
+   * // 查询某节点的所有后代
+MenuSimple.findDescendants({ entityId: root.id }).subscribe(list => console.log(list));
+
+// 仅查询直接子节点（level 1）
+MenuSimple.findDescendants({ entityId: root.id, level: 1 }).subscribe(children => console.log(children));
+   */
+  static findDescendants(options?: FindTreeOptions<typeof MenuSimple,MenuSimpleTreeRuleGroup>): Observable<MenuSimple[]>;
+  /**
+   * 查询单个实体,未找到时返回 undefined
+   * @param options 查询选项
+   * @example
+   * MenuSimple.findOne({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
+   */
+  static findOne(options: FindOneOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>): Observable<MenuSimple | undefined>;
+  /**
+   * 查询单个实体,未找到时抛出错误
+   * @param options 查询选项
+   * @example
+   * MenuSimple.findOneOrFail({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
+   */
+  static findOneOrFail(options: FindOneOrFailOptions<typeof MenuSimple,MenuSimpleRuleGroup,MenuSimpleOrderByField>): Observable<MenuSimple>;
+  /**
+   * 根据 ID 获取单个实体
+   * @param options 查询选项
+   * @example
+   * MenuSimple.get('123').subscribe(entity => console.log(entity));
+   */
+  static get(options: UUID): Observable<MenuSimple>;
+  /**
+   * 删除
+   */
+  remove(): Promise<MenuSimple>;
+  /**
+   * 重置数据
+   */
+  reset(): void;
+  /**
+   * 保存
+   */
+  save(): Promise<MenuSimple>;
+}
+
+/**
+ * MenuLarge
  */
-export declare class Menu extends TreeAdjacencyListEntityBase implements IEntityStaticType, ITreeEntity {
-  static [ENTITY_STATIC_TYPES]: MenuStaticTypes;
+export declare class MenuLarge extends TreeAdjacencyListEntityBase implements ITreeEntity {
+  static [ENTITY_STATIC_TYPES]: MenuLargeStaticTypes;
   /**
    * children
    */
-  children$: RelationEntitiesObservable<Menu>;
+  readonly children$: RelationEntitiesObservable<MenuLarge>;
+  /**
+   * hasChildren
+   */
+  readonly hasChildren?: boolean | null;
   /**
    * parent
    */
-  parent$: RelationEntityObservable<Menu | null>;
+  readonly parent$: RelationEntityObservable<typeof MenuLarge>;
   /**
    * parent id
    */
-  parentId?: UUID;
+  parentId?: UUID | null;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
   /**
    * title
    */
@@ -593,66 +1287,388 @@ export declare class Menu extends TreeAdjacencyListEntityBase implements IEntity
    * 初始化数据
    * @param initData 初始化数据
    */
-  constructor(initData?: MenuInitData);
+  constructor(initData?: MenuLargeInitData);
+  /**
+   * 统计实体数量
+   * @param options 查询选项
+   * @example
+   * MenuLarge.count({ where: { combinator: 'and', rules: [] } }).subscribe(total => console.log(total));
+   */
+  static count(options: CountOptions<typeof MenuLarge,MenuLargeRuleGroup>): Observable<number>;
+  /**
+   * 统计祖先实体数量（不包含自身）
+   * @param options 查询选项
+   * @example
+   * // 统计某节点的祖先层级深度
+MenuLarge.countAncestors({ entityId: grand.id }).subscribe(depth => console.log(depth));
+   */
+  static countAncestors(options?: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>): Observable<number>;
+  /**
+   * 统计子孙实体数量（不包含自身）
+   * @param options 查询选项
+   * @example
+   * // 统计某节点下的后代数量
+MenuLarge.countDescendants({ entityId: root.id }).subscribe(count => console.log(count));
+   */
+  static countDescendants(options?: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>): Observable<number>;
+  /**
+   * 查询多个实体
+   * @param options 查询选项
+   * @example
+   * MenuLarge.find({ where: { combinator: 'and', rules: [] }] }).subscribe(list => console.log(list));
+   */
+  static find(options: FindOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>): Observable<MenuLarge[]>;
+  /**
+   * 查询所有实体
+   * @param options 查询选项
+   * @example
+   * MenuLarge.findAll({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
+   */
+  static findAll(options: FindAllOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>): Observable<MenuLarge[]>;
+  /**
+   * 查询祖先实体（包含自身）
+   * @param options 查询选项
+   * @example
+   * // 查询某节点的所有祖先（面包屑导航）
+MenuLarge.findAncestors({ entityId: grand.id }).subscribe(ancestors => console.log(ancestors));
+
+// 仅查询直接父节点（level 1）
+MenuLarge.findAncestors({ entityId: grand.id, level: 1 }).subscribe(parents => console.log(parents));
+   */
+  static findAncestors(options?: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>): Observable<MenuLarge[]>;
+  /**
+   * 游标分页查询
+   * @param options 查询选项
+   * @example
+   * MenuLarge.findByCursor({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
+   */
+  static findByCursor(options: FindByCursorOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>): Observable<MenuLarge[]>;
+  /**
+   * 查询子孙实体（包含自身）
+   * @param options 查询选项
+   * @example
+   * // 查询某节点的所有后代
+MenuLarge.findDescendants({ entityId: root.id }).subscribe(list => console.log(list));
+
+// 仅查询直接子节点（level 1）
+MenuLarge.findDescendants({ entityId: root.id, level: 1 }).subscribe(children => console.log(children));
+   */
+  static findDescendants(options?: FindTreeOptions<typeof MenuLarge,MenuLargeTreeRuleGroup>): Observable<MenuLarge[]>;
+  /**
+   * 查询单个实体,未找到时返回 undefined
+   * @param options 查询选项
+   * @example
+   * MenuLarge.findOne({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
+   */
+  static findOne(options: FindOneOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>): Observable<MenuLarge | undefined>;
+  /**
+   * 查询单个实体,未找到时抛出错误
+   * @param options 查询选项
+   * @example
+   * MenuLarge.findOneOrFail({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
+   */
+  static findOneOrFail(options: FindOneOrFailOptions<typeof MenuLarge,MenuLargeRuleGroup,MenuLargeOrderByField>): Observable<MenuLarge>;
+  /**
+   * 根据 ID 获取单个实体
+   * @param options 查询选项
+   * @example
+   * MenuLarge.get('123').subscribe(entity => console.log(entity));
+   */
+  static get(options: UUID): Observable<MenuLarge>;
+  /**
+   * 删除
+   */
+  remove(): Promise<MenuLarge>;
+  /**
+   * 重置数据
+   */
+  reset(): void;
+  /**
+   * 保存
+   */
+  save(): Promise<MenuLarge>;
+}
+
+/**
+ * FileNode
+ */
+export declare class FileNode extends TreeAdjacencyListEntityBase implements ITreeEntity {
+  static [ENTITY_STATIC_TYPES]: FileNodeStaticTypes;
+  /**
+   * children
+   */
+  readonly children$: RelationEntitiesObservable<FileNode>;
+  /**
+   * parent
+   */
+  readonly parent$: RelationEntityObservable<typeof FileNode>;
+  /**
+   * extension
+   */
+  extension?: string | null;
+  /**
+   * name
+   */
+  name: string;
+  /**
+   * parent id
+   */
+  parentId?: UUID | null;
+  /**
+   * size
+   */
+  size?: number | null;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
+  /**
+   * type
+   */
+  type: string;
+  /**
+   * 初始化数据
+   * @param initData 初始化数据
+   */
+  constructor(initData?: FileNodeInitData);
+  /**
+   * 统计实体数量
+   * @param options 查询选项
+   * @example
+   * FileNode.count({ where: { combinator: 'and', rules: [] } }).subscribe(total => console.log(total));
+   */
+  static count(options: CountOptions<typeof FileNode,FileNodeRuleGroup>): Observable<number>;
+  /**
+   * 统计祖先实体数量（不包含自身）
+   * @param options 查询选项
+   * @example
+   * // 统计某节点的祖先层级深度
+FileNode.countAncestors({ entityId: grand.id }).subscribe(depth => console.log(depth));
+   */
+  static countAncestors(options?: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>): Observable<number>;
+  /**
+   * 统计子孙实体数量（不包含自身）
+   * @param options 查询选项
+   * @example
+   * // 统计某节点下的后代数量
+FileNode.countDescendants({ entityId: root.id }).subscribe(count => console.log(count));
+   */
+  static countDescendants(options?: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>): Observable<number>;
+  /**
+   * 查询多个实体
+   * @param options 查询选项
+   * @example
+   * FileNode.find({ where: { combinator: 'and', rules: [] }] }).subscribe(list => console.log(list));
+   */
+  static find(options: FindOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>): Observable<FileNode[]>;
+  /**
+   * 查询所有实体
+   * @param options 查询选项
+   * @example
+   * FileNode.findAll({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
+   */
+  static findAll(options: FindAllOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>): Observable<FileNode[]>;
+  /**
+   * 查询祖先实体（包含自身）
+   * @param options 查询选项
+   * @example
+   * // 查询某节点的所有祖先（面包屑导航）
+FileNode.findAncestors({ entityId: grand.id }).subscribe(ancestors => console.log(ancestors));
+
+// 仅查询直接父节点（level 1）
+FileNode.findAncestors({ entityId: grand.id, level: 1 }).subscribe(parents => console.log(parents));
+   */
+  static findAncestors(options?: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>): Observable<FileNode[]>;
+  /**
+   * 游标分页查询
+   * @param options 查询选项
+   * @example
+   * FileNode.findByCursor({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
+   */
+  static findByCursor(options: FindByCursorOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>): Observable<FileNode[]>;
+  /**
+   * 查询子孙实体（包含自身）
+   * @param options 查询选项
+   * @example
+   * // 查询某节点的所有后代
+FileNode.findDescendants({ entityId: root.id }).subscribe(list => console.log(list));
+
+// 仅查询直接子节点（level 1）
+FileNode.findDescendants({ entityId: root.id, level: 1 }).subscribe(children => console.log(children));
+   */
+  static findDescendants(options?: FindTreeOptions<typeof FileNode,FileNodeTreeRuleGroup>): Observable<FileNode[]>;
+  /**
+   * 查询单个实体,未找到时返回 undefined
+   * @param options 查询选项
+   * @example
+   * FileNode.findOne({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
+   */
+  static findOne(options: FindOneOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>): Observable<FileNode | undefined>;
+  /**
+   * 查询单个实体,未找到时抛出错误
+   * @param options 查询选项
+   * @example
+   * FileNode.findOneOrFail({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
+   */
+  static findOneOrFail(options: FindOneOrFailOptions<typeof FileNode,FileNodeRuleGroup,FileNodeOrderByField>): Observable<FileNode>;
+  /**
+   * 根据 ID 获取单个实体
+   * @param options 查询选项
+   * @example
+   * FileNode.get('123').subscribe(entity => console.log(entity));
+   */
+  static get(options: UUID): Observable<FileNode>;
+  /**
+   * 删除
+   */
+  remove(): Promise<FileNode>;
+  /**
+   * 重置数据
+   */
+  reset(): void;
+  /**
+   * 保存
+   */
+  save(): Promise<FileNode>;
+}
+
+/**
+ * FileLarge
+ */
+export declare class FileLarge extends TreeAdjacencyListEntityBase implements ITreeEntity {
+  static [ENTITY_STATIC_TYPES]: FileLargeStaticTypes;
+  /**
+   * children
+   */
+  readonly children$: RelationEntitiesObservable<FileLarge>;
+  /**
+   * hasChildren
+   */
+  readonly hasChildren?: boolean | null;
+  /**
+   * parent
+   */
+  readonly parent$: RelationEntityObservable<typeof FileLarge>;
+  /**
+   * extension
+   */
+  extension?: string | null;
+  /**
+   * name
+   */
+  name: string;
+  /**
+   * parent id
+   */
+  parentId?: UUID | null;
+  /**
+   * size
+   */
+  size?: number | null;
+  /**
+   * sortOrder
+   */
+  sortOrder?: string | null;
+  /**
+   * type
+   */
+  type: string;
+  /**
+   * 初始化数据
+   * @param initData 初始化数据
+   */
+  constructor(initData?: FileLargeInitData);
   /**
-   * count 查询
+   * 统计实体数量
    * @param options 查询选项
+   * @example
+   * FileLarge.count({ where: { combinator: 'and', rules: [] } }).subscribe(total => console.log(total));
    */
-  static count(options: CountOptions<typeof Menu,MenuRuleGroup>): Observable<number>;
+  static count(options: CountOptions<typeof FileLarge,FileLargeRuleGroup>): Observable<number>;
   /**
-   * 查询祖先实体数量
+   * 统计祖先实体数量（不包含自身）
    * @param options 查询选项
+   * @example
+   * // 统计某节点的祖先层级深度
+FileLarge.countAncestors({ entityId: grand.id }).subscribe(depth => console.log(depth));
    */
-  static countAncestors(options?: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>): Observable<number>;
+  static countAncestors(options?: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>): Observable<number>;
   /**
-   * 查询子孙实体数量
+   * 统计子孙实体数量（不包含自身）
    * @param options 查询选项
+   * @example
+   * // 统计某节点下的后代数量
+FileLarge.countDescendants({ entityId: root.id }).subscribe(count => console.log(count));
    */
-  static countDescendants(options?: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>): Observable<number>;
+  static countDescendants(options?: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>): Observable<number>;
   /**
-   * find 查询
+   * 查询多个实体
    * @param options 查询选项
+   * @example
+   * FileLarge.find({ where: { combinator: 'and', rules: [] }] }).subscribe(list => console.log(list));
    */
-  static find(options: FindOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>): Observable<Menu[]>;
+  static find(options: FindOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>): Observable<FileLarge[]>;
   /**
-   * findAll 查询
+   * 查询所有实体
    * @param options 查询选项
+   * @example
+   * FileLarge.findAll({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
    */
-  static findAll(options: FindAllOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>): Observable<Menu[]>;
+  static findAll(options: FindAllOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>): Observable<FileLarge[]>;
   /**
-   * 查询祖先实体
+   * 查询祖先实体（包含自身）
    * @param options 查询选项
+   * @example
+   * // 查询某节点的所有祖先（面包屑导航）
+FileLarge.findAncestors({ entityId: grand.id }).subscribe(ancestors => console.log(ancestors));
+
+// 仅查询直接父节点（level 1）
+FileLarge.findAncestors({ entityId: grand.id, level: 1 }).subscribe(parents => console.log(parents));
    */
-  static findAncestors(options?: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>): Observable<Menu[]>;
+  static findAncestors(options?: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>): Observable<FileLarge[]>;
   /**
-   * findByCursor 查询
+   * 游标分页查询
    * @param options 查询选项
+   * @example
+   * FileLarge.findByCursor({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));
    */
-  static findByCursor(options: FindByCursorOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>): Observable<Menu[]>;
+  static findByCursor(options: FindByCursorOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>): Observable<FileLarge[]>;
   /**
-   * 查询子孙实体
+   * 查询子孙实体（包含自身）
    * @param options 查询选项
+   * @example
+   * // 查询某节点的所有后代
+FileLarge.findDescendants({ entityId: root.id }).subscribe(list => console.log(list));
+
+// 仅查询直接子节点（level 1）
+FileLarge.findDescendants({ entityId: root.id, level: 1 }).subscribe(children => console.log(children));
    */
-  static findDescendants(options?: FindTreeOptions<typeof Menu,MenuTreeRuleGroup>): Observable<Menu[]>;
+  static findDescendants(options?: FindTreeOptions<typeof FileLarge,FileLargeTreeRuleGroup>): Observable<FileLarge[]>;
   /**
-   * findOne 查询
+   * 查询单个实体,未找到时返回 undefined
    * @param options 查询选项
+   * @example
+   * FileLarge.findOne({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
    */
-  static findOne(options: FindOneOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>): Observable<Menu | undefined>;
+  static findOne(options: FindOneOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>): Observable<FileLarge | undefined>;
   /**
-   * findOneOrFail 查询
+   * 查询单个实体,未找到时抛出错误
    * @param options 查询选项
+   * @example
+   * FileLarge.findOneOrFail({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));
    */
-  static findOneOrFail(options: FindOneOrFailOptions<typeof Menu,MenuRuleGroup,MenuOrderByField>): Observable<Menu>;
+  static findOneOrFail(options: FindOneOrFailOptions<typeof FileLarge,FileLargeRuleGroup,FileLargeOrderByField>): Observable<FileLarge>;
   /**
-   * get 查询
+   * 根据 ID 获取单个实体
    * @param options 查询选项
+   * @example
+   * FileLarge.get('123').subscribe(entity => console.log(entity));
    */
-  static get(options: UUID): Observable<Menu>;
+  static get(options: UUID): Observable<FileLarge>;
   /**
    * 删除
    */
-  remove(): Promise<Menu>;
+  remove(): Promise<FileLarge>;
   /**
    * 重置数据
    */
@@ -660,7 +1676,7 @@ export declare class Menu extends TreeAdjacencyListEntityBase implements IEntity
   /**
    * 保存
    */
-  save(): Promise<Menu>;
+  save(): Promise<FileLarge>;
 }
 
 export declare const ENTITIES: EntityType[];