vona-module-test-vona 5.0.27 → 5.0.29

package/dist/.metadata/index.d.ts

@@ -1,6 +1,5 @@
-import type { TypeMetaEntity } from 'vona-module-a-database';
-import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';
-import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+import type { TypeEntityMeta, TypeModelsClassLikeGeneral, TypeSymbolKeyFieldsMore, IModelRelationHasOne, IModelRelationBelongsTo, IModelRelationHasMany, IModelRelationBelongsToMany } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields, TypeControllerOptionsActions } from 'vona-module-a-openapi';
 /** aop: begin */
 export * from '../bean/aop.regExp.ts';
 export * from '../bean/aop.simple.ts';
@@ -14,7 +13,15 @@ declare module 'vona-module-a-aspect' {
 declare module 'vona-module-test-vona' {
     interface AopRegExp {
     }
+    interface AopRegExp {
+        get $beanFullName(): 'test-vona.aop.regExp';
+        get $onionName(): 'test-vona:regExp';
+    }
+    interface AopSimple {
+    }
     interface AopSimple {
+        get $beanFullName(): 'test-vona.aop.simple';
+        get $onionName(): 'test-vona:simple';
     }
 }
 /** aop: end */
@@ -30,62 +37,490 @@ declare module 'vona-module-a-aspect' {
 declare module 'vona-module-test-vona' {
     interface AopMethodTest {
     }
+    interface AopMethodTest {
+        get $beanFullName(): 'test-vona.aopMethod.test';
+        get $onionName(): 'test-vona:test';
+    }
 }
 /** aopMethod: end */
 /** entity: begin */
+export * from '../entity/category.ts';
+export * from '../entity/post.ts';
+export * from '../entity/postContent.ts';
+export * from '../entity/role.ts';
+export * from '../entity/roleUser.ts';
 export * from '../entity/test.ts';
+export * from '../entity/user.ts';
+import type { IEntityOptionsCategory } from '../entity/category.ts';
+import type { IEntityOptionsPost } from '../entity/post.ts';
+import type { IEntityOptionsPostContent } from '../entity/postContent.ts';
+import type { IEntityOptionsRole } from '../entity/role.ts';
+import type { IEntityOptionsRoleUser } from '../entity/roleUser.ts';
 import type { IEntityOptionsTest } from '../entity/test.ts';
+import type { IEntityOptionsUser } from '../entity/user.ts';
 import 'vona';
-declare module 'vona-module-a-database' {
+declare module 'vona-module-a-orm' {
     interface IEntityRecord {
-        'test-vona:test': Omit<IEntityOptionsTest, '_fieldsMore_'>;
+        'test-vona:category': IEntityOptionsCategory;
+        'test-vona:post': IEntityOptionsPost;
+        'test-vona:postContent': IEntityOptionsPostContent;
+        'test-vona:role': IEntityOptionsRole;
+        'test-vona:roleUser': IEntityOptionsRoleUser;
+        'test-vona:test': IEntityOptionsTest;
+        'test-vona:user': IEntityOptionsUser;
     }
 }
 declare module 'vona-module-test-vona' {
 }
 /** entity: end */
 /** entity: begin */
+import type { EntityCategory } from '../entity/category.ts';
+import type { EntityPost } from '../entity/post.ts';
+import type { EntityPostContent } from '../entity/postContent.ts';
+import type { EntityRole } from '../entity/role.ts';
+import type { EntityRoleUser } from '../entity/roleUser.ts';
 import type { EntityTest } from '../entity/test.ts';
+import type { EntityUser } from '../entity/user.ts';
 export interface IModuleEntity {
-    'test': TypeMetaEntity<EntityTest, EntityTestTableName>;
+    'category': EntityCategoryMeta;
+    'post': EntityPostMeta;
+    'postContent': EntityPostContentMeta;
+    'role': EntityRoleMeta;
+    'roleUser': EntityRoleUserMeta;
+    'test': EntityTestMeta;
+    'user': EntityUserMeta;
 }
 /** entity: end */
 /** entity: begin */
-export type EntityTestTableName = 'testVona';
-declare module 'vona-module-a-database' {
+export type EntityCategoryTableName = 'testVonaCategory';
+export type EntityPostTableName = 'testVonaPost';
+export type EntityPostContentTableName = 'testVonaPostContent';
+export type EntityRoleTableName = 'testVonaRole';
+export type EntityRoleUserTableName = 'testVonaRoleUser';
+export type EntityTestTableName = 'testVonaTest';
+export type EntityUserTableName = 'testVonaUser';
+export type EntityCategoryMeta = TypeEntityMeta<EntityCategory, EntityCategoryTableName>;
+export type EntityPostMeta = TypeEntityMeta<EntityPost, EntityPostTableName>;
+export type EntityPostContentMeta = TypeEntityMeta<EntityPostContent, EntityPostContentTableName>;
+export type EntityRoleMeta = TypeEntityMeta<EntityRole, EntityRoleTableName>;
+export type EntityRoleUserMeta = TypeEntityMeta<EntityRoleUser, EntityRoleUserTableName>;
+export type EntityTestMeta = TypeEntityMeta<EntityTest, EntityTestTableName>;
+export type EntityUserMeta = TypeEntityMeta<EntityUser, EntityUserTableName>;
+declare module 'vona-module-a-orm' {
     interface ITableRecord {
-        'testVona': never;
+        'testVonaCategory': never;
+        'testVonaPost': never;
+        'testVonaPostContent': never;
+        'testVonaRole': never;
+        'testVonaRoleUser': never;
+        'testVonaTest': never;
+        'testVonaUser': never;
     }
 }
 declare module 'vona-module-test-vona' {
+    interface IEntityOptionsCategory {
+        fields?: TypeEntityOptionsFields<EntityCategory, IEntityOptionsCategory[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IEntityOptionsPost {
+        fields?: TypeEntityOptionsFields<EntityPost, IEntityOptionsPost[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IEntityOptionsPostContent {
+        fields?: TypeEntityOptionsFields<EntityPostContent, IEntityOptionsPostContent[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IEntityOptionsRole {
+        fields?: TypeEntityOptionsFields<EntityRole, IEntityOptionsRole[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IEntityOptionsRoleUser {
+        fields?: TypeEntityOptionsFields<EntityRoleUser, IEntityOptionsRoleUser[TypeSymbolKeyFieldsMore]>;
+    }
     interface IEntityOptionsTest {
-        fields?: TypeEntityOptionsFields<EntityTest, IEntityOptionsTest['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<EntityTest, IEntityOptionsTest[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IEntityOptionsUser {
+        fields?: TypeEntityOptionsFields<EntityUser, IEntityOptionsUser[TypeSymbolKeyFieldsMore]>;
     }
 }
 /** entity: end */
 /** model: begin */
+export * from '../model/category.ts';
+export * from '../model/post.ts';
+export * from '../model/postContent.ts';
+export * from '../model/role.ts';
+export * from '../model/roleUser.ts';
 export * from '../model/test.ts';
 export * from '../model/testDynamicTable.ts';
-import { type IDecoratorModelOptions } from 'vona-module-a-database';
-declare module 'vona-module-a-database' {
+export * from '../model/user.ts';
+export * from '../model/userStats.ts';
+export * from '../model/userStatsGroup.ts';
+import type { IModelOptionsCategory } from '../model/category.ts';
+import type { IModelOptionsPost } from '../model/post.ts';
+import type { IModelOptionsPostContent } from '../model/postContent.ts';
+import type { IModelOptionsRole } from '../model/role.ts';
+import type { IModelOptionsRoleUser } from '../model/roleUser.ts';
+import type { IModelOptionsTest } from '../model/test.ts';
+import type { IModelOptionsTestDynamicTable } from '../model/testDynamicTable.ts';
+import type { IModelOptionsUser } from '../model/user.ts';
+import type { IModelOptionsUserStats } from '../model/userStats.ts';
+import type { IModelOptionsUserStatsGroup } from '../model/userStatsGroup.ts';
+import 'vona';
+declare module 'vona-module-a-orm' {
     interface IModelRecord {
-        'test-vona:test': IDecoratorModelOptions;
-        'test-vona:testDynamicTable': IDecoratorModelOptions;
+        'test-vona:category': IModelOptionsCategory;
+        'test-vona:post': IModelOptionsPost;
+        'test-vona:postContent': IModelOptionsPostContent;
+        'test-vona:role': IModelOptionsRole;
+        'test-vona:roleUser': IModelOptionsRoleUser;
+        'test-vona:test': IModelOptionsTest;
+        'test-vona:testDynamicTable': IModelOptionsTestDynamicTable;
+        'test-vona:user': IModelOptionsUser;
+        'test-vona:userStats': IModelOptionsUserStats;
+        'test-vona:userStatsGroup': IModelOptionsUserStatsGroup;
     }
 }
 declare module 'vona-module-test-vona' {
+    interface ModelCategory {
+    }
+    interface ModelCategory {
+        get $beanFullName(): 'test-vona.model.category';
+        get $onionName(): 'test-vona:category';
+    }
+    interface ModelPost {
+    }
+    interface ModelPost {
+        get $beanFullName(): 'test-vona.model.post';
+        get $onionName(): 'test-vona:post';
+    }
+    interface ModelPostContent {
+    }
+    interface ModelPostContent {
+        get $beanFullName(): 'test-vona.model.postContent';
+        get $onionName(): 'test-vona:postContent';
+    }
+    interface ModelRole {
+    }
+    interface ModelRole {
+        get $beanFullName(): 'test-vona.model.role';
+        get $onionName(): 'test-vona:role';
+    }
+    interface ModelRoleUser {
+    }
+    interface ModelRoleUser {
+        get $beanFullName(): 'test-vona.model.roleUser';
+        get $onionName(): 'test-vona:roleUser';
+    }
+    interface ModelTest {
+    }
     interface ModelTest {
+        get $beanFullName(): 'test-vona.model.test';
+        get $onionName(): 'test-vona:test';
     }
     interface ModelTestDynamicTable {
     }
+    interface ModelTestDynamicTable {
+        get $beanFullName(): 'test-vona.model.testDynamicTable';
+        get $onionName(): 'test-vona:testDynamicTable';
+    }
+    interface ModelUser {
+    }
+    interface ModelUser {
+        get $beanFullName(): 'test-vona.model.user';
+        get $onionName(): 'test-vona:user';
+    }
+    interface ModelUserStats {
+    }
+    interface ModelUserStats {
+        get $beanFullName(): 'test-vona.model.userStats';
+        get $onionName(): 'test-vona:userStats';
+    }
+    interface ModelUserStatsGroup {
+    }
+    interface ModelUserStatsGroup {
+        get $beanFullName(): 'test-vona.model.userStatsGroup';
+        get $onionName(): 'test-vona:userStatsGroup';
+    }
 }
 /** model: end */
 /** model: begin */
+import type { ModelCategory } from '../model/category.ts';
+import type { ModelPost } from '../model/post.ts';
+import type { ModelPostContent } from '../model/postContent.ts';
+import type { ModelRole } from '../model/role.ts';
+import type { ModelRoleUser } from '../model/roleUser.ts';
 import type { ModelTest } from '../model/test.ts';
 import type { ModelTestDynamicTable } from '../model/testDynamicTable.ts';
+import type { ModelUser } from '../model/user.ts';
+import type { ModelUserStats } from '../model/userStats.ts';
+import type { ModelUserStatsGroup } from '../model/userStatsGroup.ts';
 export interface IModuleModel {
+    'category': ModelCategory;
+    'post': ModelPost;
+    'postContent': ModelPostContent;
+    'role': ModelRole;
+    'roleUser': ModelRoleUser;
     'test': ModelTest;
     'testDynamicTable': ModelTestDynamicTable;
+    'user': ModelUser;
+    'userStats': ModelUserStats;
+    'userStatsGroup': ModelUserStatsGroup;
+}
+/** model: end */
+/** model: begin */
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TableIdentity, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
+declare module 'vona-module-test-vona' {
+    interface IModelOptionsCategory {
+        relations: {
+            children: IModelRelationHasMany<ModelCategory, true, 'id' | 'name', undefined, undefined, undefined>;
+        };
+    }
+    interface IModelOptionsPost {
+        relations: {
+            postContent: IModelRelationHasOne<'test-vona:postContent', false, 'id' | 'content'>;
+            user: IModelRelationBelongsTo<ModelPost, ModelUser, true, 'id' | 'name'>;
+        };
+    }
+    interface IModelOptionsPostContent {
+        relations: {
+            post: IModelRelationBelongsTo<ModelPostContent, ModelPost, false, '*'>;
+        };
+    }
+    interface IModelOptionsRole {
+        relations: {
+            users: IModelRelationBelongsToMany<ModelRoleUser, ModelUser, false, 'id' | 'name', undefined, undefined, undefined>;
+        };
+    }
+    interface IModelOptionsUser {
+        relations: {
+            posts: IModelRelationHasMany<ModelPost, false, 'id' | 'title', ['test-vona:user', ModelPostContent], undefined, undefined>;
+            roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, 'id' | 'name', undefined, undefined, undefined>;
+        };
+    }
+    interface IModelOptionsUserStats {
+        relations: {
+            posts: IModelRelationHasMany<ModelPost, true, '*', undefined, {
+                count?: '*' | 'title' | Array<'*' | 'title'>;
+                sum?: 'stars' | Array<'stars'>;
+            }, undefined>;
+            roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, '*', undefined, {
+                count?: '*' | Array<'*'>;
+            }, undefined>;
+        };
+    }
+    interface IModelOptionsUserStatsGroup {
+        relations: {
+            posts: IModelRelationHasMany<ModelPost, true, undefined, undefined, {
+                count?: '*' | 'title' | Array<'*' | 'title'>;
+                sum?: 'stars' | Array<'stars'>;
+            }, 'title' | Array<'title'>>;
+            roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, undefined, undefined, {
+                count?: '*' | Array<'*'>;
+            }, 'name' | Array<'name'>>;
+        };
+    }
+    interface ModelCategory {
+        [SymbolKeyEntity]: EntityCategory;
+        [SymbolKeyEntityMeta]: EntityCategoryMeta;
+        [SymbolKeyModelOptions]: IModelOptionsCategory;
+        get<T extends IModelGetOptions<EntityCategory, ModelCategory>>(where: TypeModelWhere<EntityCategory>, options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityCategory, ModelCategory>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T>[]>;
+        select<T extends IModelSelectParams<EntityCategory, ModelCategory, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T>[]>;
+        insert<T extends IModelInsertOptions<EntityCategory, ModelCategory>>(data?: TypeModelMutateRelationData<EntityCategory, ModelCategory, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityCategory, ModelCategory, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityCategory, ModelCategory>>(items: TypeModelMutateRelationData<EntityCategory, ModelCategory, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityCategory, ModelCategory, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityCategory, ModelCategory>>(data: TypeModelMutateRelationData<EntityCategory, ModelCategory, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategory, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityCategory, ModelCategory>>(items: TypeModelMutateRelationData<EntityCategory, ModelCategory, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategory, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityCategory, ModelCategory>>(where?: TypeModelWhere<EntityCategory>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityCategory, ModelCategory>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityCategory, ModelCategory>>(data?: TypeModelMutateRelationData<EntityCategory, ModelCategory, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategory, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityCategory, ModelCategory>>(items: TypeModelMutateRelationData<EntityCategory, ModelCategory, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategory, T>[]>;
+        count<T extends IModelSelectCountParams<EntityCategory, ModelCategory, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityCategory, ModelCategory, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityCategory, ModelCategory, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityCategory, T>[]>;
+    }
+    interface ModelPost {
+        [SymbolKeyEntity]: EntityPost;
+        [SymbolKeyEntityMeta]: EntityPostMeta;
+        [SymbolKeyModelOptions]: IModelOptionsPost;
+        get<T extends IModelGetOptions<EntityPost, ModelPost>>(where: TypeModelWhere<EntityPost>, options?: T): Promise<TypeModelRelationResult<EntityPost, ModelPost, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityPost, ModelPost>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityPost, ModelPost, T>[]>;
+        select<T extends IModelSelectParams<EntityPost, ModelPost, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityPost, ModelPost, T>[]>;
+        insert<T extends IModelInsertOptions<EntityPost, ModelPost>>(data?: TypeModelMutateRelationData<EntityPost, ModelPost, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityPost, ModelPost, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityPost, ModelPost>>(items: TypeModelMutateRelationData<EntityPost, ModelPost, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityPost, ModelPost, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityPost, ModelPost>>(data: TypeModelMutateRelationData<EntityPost, ModelPost, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPost, ModelPost, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityPost, ModelPost>>(items: TypeModelMutateRelationData<EntityPost, ModelPost, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPost, ModelPost, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityPost, ModelPost>>(where?: TypeModelWhere<EntityPost>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityPost, ModelPost>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityPost, ModelPost>>(data?: TypeModelMutateRelationData<EntityPost, ModelPost, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPost, ModelPost, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityPost, ModelPost>>(items: TypeModelMutateRelationData<EntityPost, ModelPost, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPost, ModelPost, T>[]>;
+        count<T extends IModelSelectCountParams<EntityPost, ModelPost, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityPost, ModelPost, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityPost, ModelPost, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityPost, T>[]>;
+    }
+    interface ModelPostContent {
+        [SymbolKeyEntity]: EntityPostContent;
+        [SymbolKeyEntityMeta]: EntityPostContentMeta;
+        [SymbolKeyModelOptions]: IModelOptionsPostContent;
+        get<T extends IModelGetOptions<EntityPostContent, ModelPostContent>>(where: TypeModelWhere<EntityPostContent>, options?: T): Promise<TypeModelRelationResult<EntityPostContent, ModelPostContent, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityPostContent, ModelPostContent>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityPostContent, ModelPostContent, T>[]>;
+        select<T extends IModelSelectParams<EntityPostContent, ModelPostContent, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityPostContent, ModelPostContent, T>[]>;
+        insert<T extends IModelInsertOptions<EntityPostContent, ModelPostContent>>(data?: TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityPostContent, ModelPostContent>>(items: TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityPostContent, ModelPostContent>>(data: TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityPostContent, ModelPostContent>>(items: TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityPostContent, ModelPostContent>>(where?: TypeModelWhere<EntityPostContent>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityPostContent, ModelPostContent>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityPostContent, ModelPostContent>>(data?: TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityPostContent, ModelPostContent>>(items: TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPostContent, ModelPostContent, T>[]>;
+        count<T extends IModelSelectCountParams<EntityPostContent, ModelPostContent, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityPostContent, ModelPostContent, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityPostContent, ModelPostContent, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityPostContent, T>[]>;
+    }
+    interface ModelRole {
+        [SymbolKeyEntity]: EntityRole;
+        [SymbolKeyEntityMeta]: EntityRoleMeta;
+        [SymbolKeyModelOptions]: IModelOptionsRole;
+        get<T extends IModelGetOptions<EntityRole, ModelRole>>(where: TypeModelWhere<EntityRole>, options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityRole, ModelRole>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
+        select<T extends IModelSelectParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
+        insert<T extends IModelInsertOptions<EntityRole, ModelRole>>(data?: TypeModelMutateRelationData<EntityRole, ModelRole, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityRole, ModelRole, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityRole, ModelRole>>(items: TypeModelMutateRelationData<EntityRole, ModelRole, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityRole, ModelRole, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityRole, ModelRole>>(data: TypeModelMutateRelationData<EntityRole, ModelRole, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityRole, ModelRole>>(items: TypeModelMutateRelationData<EntityRole, ModelRole, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityRole, ModelRole>>(where?: TypeModelWhere<EntityRole>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityRole, ModelRole>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityRole, ModelRole>>(data?: TypeModelMutateRelationData<EntityRole, ModelRole, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityRole, ModelRole>>(items: TypeModelMutateRelationData<EntityRole, ModelRole, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>[]>;
+        count<T extends IModelSelectCountParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityRole, T>[]>;
+    }
+    interface ModelRoleUser {
+        [SymbolKeyEntity]: EntityRoleUser;
+        [SymbolKeyEntityMeta]: EntityRoleUserMeta;
+        [SymbolKeyModelOptions]: IModelOptionsRoleUser;
+        get<T extends IModelGetOptions<EntityRoleUser, ModelRoleUser>>(where: TypeModelWhere<EntityRoleUser>, options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityRoleUser, ModelRoleUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
+        select<T extends IModelSelectParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
+        insert<T extends IModelInsertOptions<EntityRoleUser, ModelRoleUser>>(data?: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityRoleUser, ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityRoleUser, ModelRoleUser>>(data: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityRoleUser, ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityRoleUser, ModelRoleUser>>(where?: TypeModelWhere<EntityRoleUser>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityRoleUser, ModelRoleUser>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityRoleUser, ModelRoleUser>>(data?: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityRoleUser, ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[]>;
+        count<T extends IModelSelectCountParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityRoleUser, T>[]>;
+    }
+    interface ModelTest {
+        [SymbolKeyEntity]: EntityTest;
+        [SymbolKeyEntityMeta]: EntityTestMeta;
+        [SymbolKeyModelOptions]: IModelOptionsTest;
+        get<T extends IModelGetOptions<EntityTest, ModelTest>>(where: TypeModelWhere<EntityTest>, options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTest, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityTest, ModelTest>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTest, T>[]>;
+        select<T extends IModelSelectParams<EntityTest, ModelTest, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityTest, ModelTest, T>[]>;
+        insert<T extends IModelInsertOptions<EntityTest, ModelTest>>(data?: TypeModelMutateRelationData<EntityTest, ModelTest, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityTest, ModelTest, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityTest, ModelTest>>(items: TypeModelMutateRelationData<EntityTest, ModelTest, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityTest, ModelTest, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityTest, ModelTest>>(data: TypeModelMutateRelationData<EntityTest, ModelTest, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTest, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityTest, ModelTest>>(items: TypeModelMutateRelationData<EntityTest, ModelTest, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTest, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityTest, ModelTest>>(where?: TypeModelWhere<EntityTest>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityTest, ModelTest>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityTest, ModelTest>>(data?: TypeModelMutateRelationData<EntityTest, ModelTest, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTest, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityTest, ModelTest>>(items: TypeModelMutateRelationData<EntityTest, ModelTest, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTest, T>[]>;
+        count<T extends IModelSelectCountParams<EntityTest, ModelTest, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityTest, ModelTest, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityTest, ModelTest, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityTest, T>[]>;
+    }
+    interface ModelTestDynamicTable {
+        [SymbolKeyEntity]: EntityTest;
+        [SymbolKeyEntityMeta]: EntityTestMeta;
+        [SymbolKeyModelOptions]: IModelOptionsTestDynamicTable;
+        get<T extends IModelGetOptions<EntityTest, ModelTestDynamicTable>>(where: TypeModelWhere<EntityTest>, options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTestDynamicTable, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityTest, ModelTestDynamicTable>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTestDynamicTable, T>[]>;
+        select<T extends IModelSelectParams<EntityTest, ModelTestDynamicTable, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityTest, ModelTestDynamicTable, T>[]>;
+        insert<T extends IModelInsertOptions<EntityTest, ModelTestDynamicTable>>(data?: TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityTest, ModelTestDynamicTable>>(items: TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityTest, ModelTestDynamicTable>>(data: TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityTest, ModelTestDynamicTable>>(items: TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityTest, ModelTestDynamicTable>>(where?: TypeModelWhere<EntityTest>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityTest, ModelTestDynamicTable>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityTest, ModelTestDynamicTable>>(data?: TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityTest, ModelTestDynamicTable>>(items: TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest, ModelTestDynamicTable, T>[]>;
+        count<T extends IModelSelectCountParams<EntityTest, ModelTestDynamicTable, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityTest, ModelTestDynamicTable, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityTest, ModelTestDynamicTable, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityTest, T>[]>;
+    }
+    interface ModelUser {
+        [SymbolKeyEntity]: EntityUser;
+        [SymbolKeyEntityMeta]: EntityUserMeta;
+        [SymbolKeyModelOptions]: IModelOptionsUser;
+        get<T extends IModelGetOptions<EntityUser, ModelUser>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityUser, ModelUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
+        select<T extends IModelSelectParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
+        insert<T extends IModelInsertOptions<EntityUser, ModelUser>>(data?: TypeModelMutateRelationData<EntityUser, ModelUser, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUser, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityUser, ModelUser>>(items: TypeModelMutateRelationData<EntityUser, ModelUser, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUser, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityUser, ModelUser>>(data: TypeModelMutateRelationData<EntityUser, ModelUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityUser, ModelUser>>(items: TypeModelMutateRelationData<EntityUser, ModelUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityUser, ModelUser>>(where?: TypeModelWhere<EntityUser>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityUser, ModelUser>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityUser, ModelUser>>(data?: TypeModelMutateRelationData<EntityUser, ModelUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityUser, ModelUser>>(items: TypeModelMutateRelationData<EntityUser, ModelUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>[]>;
+        count<T extends IModelSelectCountParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityUser, T>[]>;
+    }
+    interface ModelUserStats {
+        [SymbolKeyEntity]: EntityUser;
+        [SymbolKeyEntityMeta]: EntityUserMeta;
+        [SymbolKeyModelOptions]: IModelOptionsUserStats;
+        get<T extends IModelGetOptions<EntityUser, ModelUserStats>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStats, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityUser, ModelUserStats>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStats, T>[]>;
+        select<T extends IModelSelectParams<EntityUser, ModelUserStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUserStats, T>[]>;
+        insert<T extends IModelInsertOptions<EntityUser, ModelUserStats>>(data?: TypeModelMutateRelationData<EntityUser, ModelUserStats, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUserStats, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityUser, ModelUserStats>>(items: TypeModelMutateRelationData<EntityUser, ModelUserStats, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUserStats, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityUser, ModelUserStats>>(data: TypeModelMutateRelationData<EntityUser, ModelUserStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStats, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityUser, ModelUserStats>>(items: TypeModelMutateRelationData<EntityUser, ModelUserStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStats, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityUser, ModelUserStats>>(where?: TypeModelWhere<EntityUser>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityUser, ModelUserStats>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityUser, ModelUserStats>>(data?: TypeModelMutateRelationData<EntityUser, ModelUserStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStats, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityUser, ModelUserStats>>(items: TypeModelMutateRelationData<EntityUser, ModelUserStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStats, T>[]>;
+        count<T extends IModelSelectCountParams<EntityUser, ModelUserStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityUser, ModelUserStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityUser, ModelUserStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityUser, T>[]>;
+    }
+    interface ModelUserStatsGroup {
+        [SymbolKeyEntity]: EntityUser;
+        [SymbolKeyEntityMeta]: EntityUserMeta;
+        [SymbolKeyModelOptions]: IModelOptionsUserStatsGroup;
+        get<T extends IModelGetOptions<EntityUser, ModelUserStatsGroup>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStatsGroup, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityUser, ModelUserStatsGroup>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStatsGroup, T>[]>;
+        select<T extends IModelSelectParams<EntityUser, ModelUserStatsGroup, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUserStatsGroup, T>[]>;
+        insert<T extends IModelInsertOptions<EntityUser, ModelUserStatsGroup>>(data?: TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityUser, ModelUserStatsGroup>>(items: TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityUser, ModelUserStatsGroup>>(data: TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityUser, ModelUserStatsGroup>>(items: TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityUser, ModelUserStatsGroup>>(where?: TypeModelWhere<EntityUser>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityUser, ModelUserStatsGroup>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityUser, ModelUserStatsGroup>>(data?: TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityUser, ModelUserStatsGroup>>(items: TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUserStatsGroup, T>[]>;
+        count<T extends IModelSelectCountParams<EntityUser, ModelUserStatsGroup, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityUser, ModelUserStatsGroup, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityUser, ModelUserStatsGroup, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityUser, T>[]>;
+    }
+}
+declare module 'vona-module-a-orm' {
+    interface IModelClassRecord {
+        'test-vona:category': ModelCategory;
+        'test-vona:post': ModelPost;
+        'test-vona:postContent': ModelPostContent;
+        'test-vona:role': ModelRole;
+        'test-vona:roleUser': ModelRoleUser;
+        'test-vona:test': ModelTest;
+        'test-vona:testDynamicTable': ModelTestDynamicTable;
+        'test-vona:user': ModelUser;
+        'test-vona:userStats': ModelUserStats;
+        'test-vona:userStatsGroup': ModelUserStatsGroup;
+    }
 }
 /** model: end */
 /** bean: begin */
@@ -113,6 +548,7 @@ export * from '../service/caching.ts';
 export * from '../service/test.ts';
 export * from '../service/testApp.ts';
 export * from '../service/testClass.ts';
+export * from '../service/testData.ts';
 export * from '../service/transaction.ts';
 import 'vona';
 declare module 'vona-module-a-bean' {
@@ -122,22 +558,53 @@ declare module 'vona-module-a-bean' {
         'test-vona:test': never;
         'test-vona:testApp': never;
         'test-vona:testClass': never;
+        'test-vona:testData': never;
         'test-vona:transaction': never;
     }
 }
 declare module 'vona-module-test-vona' {
     interface ServiceAopMethod {
     }
+    interface ServiceAopMethod {
+        get $beanFullName(): 'test-vona.service.aopMethod';
+        get $onionName(): 'test-vona:aopMethod';
+    }
     interface ServiceCaching {
     }
+    interface ServiceCaching {
+        get $beanFullName(): 'test-vona.service.caching';
+        get $onionName(): 'test-vona:caching';
+    }
+    interface ServiceTest {
+    }
     interface ServiceTest {
+        get $beanFullName(): 'test-vona.service.test';
+        get $onionName(): 'test-vona:test';
+    }
+    interface ServiceTestApp {
     }
     interface ServiceTestApp {
+        get $beanFullName(): 'test-vona.service.testApp';
+        get $onionName(): 'test-vona:testApp';
     }
     interface ServiceTestClass {
     }
+    interface ServiceTestClass {
+        get $beanFullName(): 'test-vona.service.testClass';
+        get $onionName(): 'test-vona:testClass';
+    }
+    interface ServiceTestData {
+    }
+    interface ServiceTestData {
+        get $beanFullName(): 'test-vona.service.testData';
+        get $onionName(): 'test-vona:testData';
+    }
     interface ServiceTransaction {
     }
+    interface ServiceTransaction {
+        get $beanFullName(): 'test-vona.service.transaction';
+        get $onionName(): 'test-vona:transaction';
+    }
 }
 /** service: end */
 /** service: begin */
@@ -146,6 +613,7 @@ import type { ServiceCaching } from '../service/caching.ts';
 import type { ServiceTest } from '../service/test.ts';
 import type { ServiceTestApp } from '../service/testApp.ts';
 import type { ServiceTestClass } from '../service/testClass.ts';
+import type { ServiceTestData } from '../service/testData.ts';
 import type { ServiceTransaction } from '../service/transaction.ts';
 export interface IModuleService {
     'aopMethod': ServiceAopMethod;
@@ -153,6 +621,7 @@ export interface IModuleService {
     'test': ServiceTest;
     'testApp': ServiceTestApp;
     'testClass': ServiceTestClass;
+    'testData': ServiceTestData;
     'transaction': ServiceTransaction;
 }
 /** service: end */
@@ -165,6 +634,7 @@ declare module 'vona' {
         'test-vona.service.test': ServiceTest;
         'test-vona.service.testApp': ServiceTestApp;
         'test-vona.service.testClass': ServiceTestClass;
+        'test-vona.service.testData': ServiceTestData;
         'test-vona.service.transaction': ServiceTransaction;
     }
 }
@@ -180,6 +650,10 @@ declare module 'vona-module-a-broadcast' {
 declare module 'vona-module-test-vona' {
     interface BroadcastTest {
     }
+    interface BroadcastTest {
+        get $beanFullName(): 'test-vona.broadcast.test';
+        get $onionName(): 'test-vona:test';
+    }
 }
 /** broadcast: end */
 /** broadcast: begin */
@@ -199,6 +673,10 @@ declare module 'vona-module-a-cache' {
 declare module 'vona-module-test-vona' {
     interface CacheMemTest {
     }
+    interface CacheMemTest {
+        get $beanFullName(): 'test-vona.cacheMem.test';
+        get $onionName(): 'test-vona:test';
+    }
 }
 /** cacheMem: end */
 /** cacheMem: begin */
@@ -218,6 +696,10 @@ declare module 'vona-module-a-cache' {
 declare module 'vona-module-test-vona' {
     interface CacheRedisTest {
     }
+    interface CacheRedisTest {
+        get $beanFullName(): 'test-vona.cacheRedis.test';
+        get $onionName(): 'test-vona:test';
+    }
 }
 /** cacheRedis: end */
 /** cacheRedis: begin */
@@ -234,6 +716,10 @@ declare module 'vona' {
 declare module 'vona-module-test-vona' {
     interface EventHelloEcho {
     }
+    interface EventHelloEcho {
+        get $beanFullName(): 'test-vona.event.helloEcho';
+        get $onionName(): 'test-vona:helloEcho';
+    }
 }
 /** event: end */
 /** event: begin */
@@ -262,6 +748,10 @@ declare module 'vona-module-a-event' {
 declare module 'vona-module-test-vona' {
     interface EventListenerHelloEcho {
     }
+    interface EventListenerHelloEcho {
+        get $beanFullName(): 'test-vona.eventListener.helloEcho';
+        get $onionName(): 'test-vona:helloEcho';
+    }
 }
 /** eventListener: end */
 /** meta: begin */
@@ -275,6 +765,10 @@ declare module 'vona' {
 declare module 'vona-module-test-vona' {
     interface MetaVersion {
     }
+    interface MetaVersion {
+        get $beanFullName(): 'test-vona.meta.version';
+        get $onionName(): 'test-vona:version';
+    }
 }
 /** meta: end */
 /** queue: begin */
@@ -288,6 +782,10 @@ declare module 'vona-module-a-queue' {
 declare module 'vona-module-test-vona' {
     interface QueueTest {
     }
+    interface QueueTest {
+        get $beanFullName(): 'test-vona.queue.test';
+        get $onionName(): 'test-vona:test';
+    }
 }
 /** queue: end */
 /** queue: begin */
@@ -309,8 +807,16 @@ declare module 'vona-module-a-schedule' {
 declare module 'vona-module-test-vona' {
     interface ScheduleTest {
     }
+    interface ScheduleTest {
+        get $beanFullName(): 'test-vona.schedule.test';
+        get $onionName(): 'test-vona:test';
+    }
     interface ScheduleTest3 {
     }
+    interface ScheduleTest3 {
+        get $beanFullName(): 'test-vona.schedule.test3';
+        get $onionName(): 'test-vona:test3';
+    }
 }
 /** schedule: end */
 /** summerCache: begin */
@@ -324,6 +830,10 @@ declare module 'vona-module-a-summer' {
 declare module 'vona-module-test-vona' {
     interface SummerCacheTest {
     }
+    interface SummerCacheTest {
+        get $beanFullName(): 'test-vona.summerCache.test';
+        get $onionName(): 'test-vona:test';
+    }
 }
 /** summerCache: end */
 /** summerCache: begin */
@@ -333,29 +843,64 @@ export interface IModuleSummerCache {
 }
 /** summerCache: end */
 /** dto: begin */
+export * from '../dto/categoryTree.ts';
 export * from '../dto/profile.ts';
+export * from '../dto/roleLazy.ts';
 export * from '../dto/user.ts';
+export * from '../dto/userCreate.ts';
+export * from '../dto/userLazy.ts';
+export * from '../dto/userUpdate.ts';
+import type { IDtoOptionsCategoryTree } from '../dto/categoryTree.ts';
 import type { IDtoOptionsProfile } from '../dto/profile.ts';
+import type { IDtoOptionsRoleLazy } from '../dto/roleLazy.ts';
 import type { IDtoOptionsUser } from '../dto/user.ts';
+import type { IDtoOptionsUserCreate } from '../dto/userCreate.ts';
+import type { IDtoOptionsUserLazy } from '../dto/userLazy.ts';
+import type { IDtoOptionsUserUpdate } from '../dto/userUpdate.ts';
 import 'vona';
 declare module 'vona-module-a-web' {
     interface IDtoRecord {
-        'test-vona:profile': Omit<IDtoOptionsProfile, '_fieldsMore_'>;
-        'test-vona:user': Omit<IDtoOptionsUser, '_fieldsMore_'>;
+        'test-vona:categoryTree': IDtoOptionsCategoryTree;
+        'test-vona:profile': IDtoOptionsProfile;
+        'test-vona:roleLazy': IDtoOptionsRoleLazy;
+        'test-vona:user': IDtoOptionsUser;
+        'test-vona:userCreate': IDtoOptionsUserCreate;
+        'test-vona:userLazy': IDtoOptionsUserLazy;
+        'test-vona:userUpdate': IDtoOptionsUserUpdate;
     }
 }
 declare module 'vona-module-test-vona' {
 }
 /** dto: end */
 /** dto: begin */
+import type { DtoCategoryTree } from '../dto/categoryTree.ts';
 import type { DtoProfile } from '../dto/profile.ts';
+import type { DtoRoleLazy } from '../dto/roleLazy.ts';
 import type { DtoUser } from '../dto/user.ts';
+import type { DtoUserCreate } from '../dto/userCreate.ts';
+import type { DtoUserLazy } from '../dto/userLazy.ts';
+import type { DtoUserUpdate } from '../dto/userUpdate.ts';
 declare module 'vona-module-test-vona' {
+    interface IDtoOptionsCategoryTree {
+        fields?: TypeEntityOptionsFields<DtoCategoryTree, IDtoOptionsCategoryTree[TypeSymbolKeyFieldsMore]>;
+    }
     interface IDtoOptionsProfile {
-        fields?: TypeEntityOptionsFields<DtoProfile, IDtoOptionsProfile['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<DtoProfile, IDtoOptionsProfile[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsRoleLazy {
+        fields?: TypeEntityOptionsFields<DtoRoleLazy, IDtoOptionsRoleLazy[TypeSymbolKeyFieldsMore]>;
     }
     interface IDtoOptionsUser {
-        fields?: TypeEntityOptionsFields<DtoUser, IDtoOptionsUser['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<DtoUser, IDtoOptionsUser[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsUserCreate {
+        fields?: TypeEntityOptionsFields<DtoUserCreate, IDtoOptionsUserCreate[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsUserLazy {
+        fields?: TypeEntityOptionsFields<DtoUserLazy, IDtoOptionsUserLazy[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsUserUpdate {
+        fields?: TypeEntityOptionsFields<DtoUserUpdate, IDtoOptionsUserUpdate[TypeSymbolKeyFieldsMore]>;
     }
 }
 /** dto: end */
@@ -363,6 +908,7 @@ declare module 'vona-module-test-vona' {
 export * from '../controller/bean.ts';
 export * from '../controller/cacheMem.ts';
 export * from '../controller/cacheRedis.ts';
+export * from '../controller/dtoTest.ts';
 export * from '../controller/guardPassport.ts';
 export * from '../controller/onion.ts';
 export * from '../controller/passport.ts';
@@ -375,6 +921,7 @@ export * from '../controller/upload.ts';
 import type { IControllerOptionsBean } from '../controller/bean.ts';
 import type { IControllerOptionsCacheMem } from '../controller/cacheMem.ts';
 import type { IControllerOptionsCacheRedis } from '../controller/cacheRedis.ts';
+import type { IControllerOptionsDtoTest } from '../controller/dtoTest.ts';
 import type { IControllerOptionsGuardPassport } from '../controller/guardPassport.ts';
 import type { IControllerOptionsOnion } from '../controller/onion.ts';
 import type { IControllerOptionsPassport } from '../controller/passport.ts';
@@ -390,6 +937,7 @@ declare module 'vona-module-a-web' {
         'test-vona:bean': IControllerOptionsBean;
         'test-vona:cacheMem': IControllerOptionsCacheMem;
         'test-vona:cacheRedis': IControllerOptionsCacheRedis;
+        'test-vona:dtoTest': IControllerOptionsDtoTest;
         'test-vona:guardPassport': IControllerOptionsGuardPassport;
         'test-vona:onion': IControllerOptionsOnion;
         'test-vona:passport': IControllerOptionsPassport;
@@ -404,27 +952,81 @@ declare module 'vona-module-a-web' {
 declare module 'vona-module-test-vona' {
     interface ControllerBean {
     }
+    interface ControllerBean {
+        get $beanFullName(): 'test-vona.controller.bean';
+        get $onionName(): 'test-vona:bean';
+    }
+    interface ControllerCacheMem {
+    }
     interface ControllerCacheMem {
+        get $beanFullName(): 'test-vona.controller.cacheMem';
+        get $onionName(): 'test-vona:cacheMem';
     }
     interface ControllerCacheRedis {
     }
+    interface ControllerCacheRedis {
+        get $beanFullName(): 'test-vona.controller.cacheRedis';
+        get $onionName(): 'test-vona:cacheRedis';
+    }
+    interface ControllerDtoTest {
+    }
+    interface ControllerDtoTest {
+        get $beanFullName(): 'test-vona.controller.dtoTest';
+        get $onionName(): 'test-vona:dtoTest';
+    }
     interface ControllerGuardPassport {
     }
+    interface ControllerGuardPassport {
+        get $beanFullName(): 'test-vona.controller.guardPassport';
+        get $onionName(): 'test-vona:guardPassport';
+    }
+    interface ControllerOnion {
+    }
     interface ControllerOnion {
+        get $beanFullName(): 'test-vona.controller.onion';
+        get $onionName(): 'test-vona:onion';
     }
     interface ControllerPassport {
     }
+    interface ControllerPassport {
+        get $beanFullName(): 'test-vona.controller.passport';
+        get $onionName(): 'test-vona:passport';
+    }
     interface ControllerPerformAction {
     }
+    interface ControllerPerformAction {
+        get $beanFullName(): 'test-vona.controller.performAction';
+        get $onionName(): 'test-vona:performAction';
+    }
+    interface ControllerQueue {
+    }
     interface ControllerQueue {
+        get $beanFullName(): 'test-vona.controller.queue';
+        get $onionName(): 'test-vona:queue';
     }
     interface ControllerSummer {
     }
+    interface ControllerSummer {
+        get $beanFullName(): 'test-vona.controller.summer';
+        get $onionName(): 'test-vona:summer';
+    }
+    interface ControllerTail {
+    }
     interface ControllerTail {
+        get $beanFullName(): 'test-vona.controller.tail';
+        get $onionName(): 'test-vona:tail';
     }
     interface ControllerTransaction {
     }
+    interface ControllerTransaction {
+        get $beanFullName(): 'test-vona.controller.transaction';
+        get $onionName(): 'test-vona:transaction';
+    }
+    interface ControllerUpload {
+    }
     interface ControllerUpload {
+        get $beanFullName(): 'test-vona.controller.upload';
+        get $onionName(): 'test-vona:upload';
     }
 }
 /** controller: end */
@@ -432,6 +1034,7 @@ declare module 'vona-module-test-vona' {
 import '../controller/bean.ts';
 import '../controller/cacheMem.ts';
 import '../controller/cacheRedis.ts';
+import '../controller/dtoTest.ts';
 import '../controller/guardPassport.ts';
 import '../controller/onion.ts';
 import '../controller/passport.ts';
@@ -451,6 +1054,9 @@ declare module 'vona-module-test-vona' {
     interface IControllerOptionsCacheRedis {
         actions?: TypeControllerOptionsActions<ControllerCacheRedis>;
     }
+    interface IControllerOptionsDtoTest {
+        actions?: TypeControllerOptionsActions<ControllerDtoTest>;
+    }
     interface IControllerOptionsGuardPassport {
         actions?: TypeControllerOptionsActions<ControllerGuardPassport>;
     }
@@ -483,6 +1089,12 @@ declare module 'vona-module-a-web' {
     interface IApiPathGetRecord {
         '/test/vona/bean/test': undefined;
         '/test/vona/bean/service': undefined;
+        '/test/vona/dtoTest/getUserLazy': undefined;
+        '/test/vona/dtoTest/getUserDynamic': undefined;
+        '/test/vona/dtoTest/getUserStats': undefined;
+        '/test/vona/dtoTest/getUserStatsGroup': undefined;
+        '/test/vona/dtoTest/getCategoryTree': undefined;
+        '/test/vona/dtoTest/getCategoryTree2': undefined;
         '/test/vona/guardPassport/testUserName': undefined;
         '/test/vona/guardPassport/testUserNameFail': undefined;
         '/test/vona/guardPassport/testRoleName': undefined;
@@ -497,6 +1109,7 @@ declare module 'vona-module-a-web' {
     interface IApiPathPostRecord {
         '/test/vona/cacheMem': undefined;
         '/test/vona/cacheRedis': undefined;
+        '/test/vona/dtoTest/createUser': undefined;
         '//echo': undefined;
         '/test/vona/onion/echo2/:userId/:userName': undefined;
         '/test/vona/onion/echo4': undefined;
@@ -514,6 +1127,9 @@ declare module 'vona-module-a-web' {
         '/test/vona/upload/file': undefined;
         '/test/vona/upload/files': undefined;
     }
+    interface IApiPathPatchRecord {
+        '/test/vona/dtoTest/updateUser/:id': undefined;
+    }
 }
 /** controller: end */
 /** config: begin */
@@ -523,6 +1139,7 @@ export declare const locales: {
     'en-us': {
         User: string;
         UserId: string;
+        Test: string;
         TestHelloWorld: string;
         TestApples: string;
         TestApples_0: string;
@@ -534,6 +1151,7 @@ export declare const locales: {
     'zh-cn': {
         User: string;
         UserId: string;
+        Test: string;
         TestHelloWorld: string;
         TestApples: string;
         TestApples_0: string;