vona-module-test-vona 5.0.32 → 5.0.34

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

@@ -45,15 +45,19 @@ declare module 'vona-module-test-vona' {
 /** aopMethod: end */
 /** entity: begin */
 export * from '../entity/category.ts';
+export * from '../entity/order.ts';
 export * from '../entity/post.ts';
 export * from '../entity/postContent.ts';
+export * from '../entity/product.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 { IEntityOptionsOrder } from '../entity/order.ts';
 import type { IEntityOptionsPost } from '../entity/post.ts';
 import type { IEntityOptionsPostContent } from '../entity/postContent.ts';
+import type { IEntityOptionsProduct } from '../entity/product.ts';
 import type { IEntityOptionsRole } from '../entity/role.ts';
 import type { IEntityOptionsRoleUser } from '../entity/roleUser.ts';
 import type { IEntityOptionsTest } from '../entity/test.ts';
@@ -62,8 +66,10 @@ import 'vona';
 declare module 'vona-module-a-orm' {
     interface IEntityRecord {
         'test-vona:category': IEntityOptionsCategory;
+        'test-vona:order': IEntityOptionsOrder;
         'test-vona:post': IEntityOptionsPost;
         'test-vona:postContent': IEntityOptionsPostContent;
+        'test-vona:product': IEntityOptionsProduct;
         'test-vona:role': IEntityOptionsRole;
         'test-vona:roleUser': IEntityOptionsRoleUser;
         'test-vona:test': IEntityOptionsTest;
@@ -75,16 +81,20 @@ declare module 'vona-module-test-vona' {
 /** entity: end */
 /** entity: begin */
 import type { EntityCategory } from '../entity/category.ts';
+import type { EntityOrder } from '../entity/order.ts';
 import type { EntityPost } from '../entity/post.ts';
 import type { EntityPostContent } from '../entity/postContent.ts';
+import type { EntityProduct } from '../entity/product.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 {
     'category': EntityCategoryMeta;
+    'order': EntityOrderMeta;
     'post': EntityPostMeta;
     'postContent': EntityPostContentMeta;
+    'product': EntityProductMeta;
     'role': EntityRoleMeta;
     'roleUser': EntityRoleUserMeta;
     'test': EntityTestMeta;
@@ -93,15 +103,19 @@ export interface IModuleEntity {
 /** entity: end */
 /** entity: begin */
 export type EntityCategoryTableName = 'testVonaCategory';
+export type EntityOrderTableName = 'testVonaOrder';
 export type EntityPostTableName = 'testVonaPost';
 export type EntityPostContentTableName = 'testVonaPostContent';
+export type EntityProductTableName = 'testVonaProduct';
 export type EntityRoleTableName = 'testVonaRole';
 export type EntityRoleUserTableName = 'testVonaRoleUser';
 export type EntityTestTableName = 'testVonaTest';
 export type EntityUserTableName = 'testVonaUser';
 export type EntityCategoryMeta = TypeEntityMeta<EntityCategory, EntityCategoryTableName>;
+export type EntityOrderMeta = TypeEntityMeta<EntityOrder, EntityOrderTableName>;
 export type EntityPostMeta = TypeEntityMeta<EntityPost, EntityPostTableName>;
 export type EntityPostContentMeta = TypeEntityMeta<EntityPostContent, EntityPostContentTableName>;
+export type EntityProductMeta = TypeEntityMeta<EntityProduct, EntityProductTableName>;
 export type EntityRoleMeta = TypeEntityMeta<EntityRole, EntityRoleTableName>;
 export type EntityRoleUserMeta = TypeEntityMeta<EntityRoleUser, EntityRoleUserTableName>;
 export type EntityTestMeta = TypeEntityMeta<EntityTest, EntityTestTableName>;
@@ -109,8 +123,10 @@ export type EntityUserMeta = TypeEntityMeta<EntityUser, EntityUserTableName>;
 declare module 'vona-module-a-orm' {
     interface ITableRecord {
         'testVonaCategory': never;
+        'testVonaOrder': never;
         'testVonaPost': never;
         'testVonaPostContent': never;
+        'testVonaProduct': never;
         'testVonaRole': never;
         'testVonaRoleUser': never;
         'testVonaTest': never;
@@ -121,12 +137,18 @@ declare module 'vona-module-test-vona' {
     interface IEntityOptionsCategory {
         fields?: TypeEntityOptionsFields<EntityCategory, IEntityOptionsCategory[TypeSymbolKeyFieldsMore]>;
     }
+    interface IEntityOptionsOrder {
+        fields?: TypeEntityOptionsFields<EntityOrder, IEntityOptionsOrder[TypeSymbolKeyFieldsMore]>;
+    }
     interface IEntityOptionsPost {
         fields?: TypeEntityOptionsFields<EntityPost, IEntityOptionsPost[TypeSymbolKeyFieldsMore]>;
     }
     interface IEntityOptionsPostContent {
         fields?: TypeEntityOptionsFields<EntityPostContent, IEntityOptionsPostContent[TypeSymbolKeyFieldsMore]>;
     }
+    interface IEntityOptionsProduct {
+        fields?: TypeEntityOptionsFields<EntityProduct, IEntityOptionsProduct[TypeSymbolKeyFieldsMore]>;
+    }
     interface IEntityOptionsRole {
         fields?: TypeEntityOptionsFields<EntityRole, IEntityOptionsRole[TypeSymbolKeyFieldsMore]>;
     }
@@ -143,8 +165,12 @@ declare module 'vona-module-test-vona' {
 /** entity: end */
 /** model: begin */
 export * from '../model/category.ts';
+export * from '../model/categoryChain.ts';
+export * from '../model/order.ts';
+export * from '../model/orderStats.ts';
 export * from '../model/post.ts';
 export * from '../model/postContent.ts';
+export * from '../model/product.ts';
 export * from '../model/role.ts';
 export * from '../model/roleUser.ts';
 export * from '../model/test.ts';
@@ -153,8 +179,12 @@ export * from '../model/user.ts';
 export * from '../model/userStats.ts';
 export * from '../model/userStatsGroup.ts';
 import type { IModelOptionsCategory } from '../model/category.ts';
+import type { IModelOptionsCategoryChain } from '../model/categoryChain.ts';
+import type { IModelOptionsOrder } from '../model/order.ts';
+import type { IModelOptionsOrderStats } from '../model/orderStats.ts';
 import type { IModelOptionsPost } from '../model/post.ts';
 import type { IModelOptionsPostContent } from '../model/postContent.ts';
+import type { IModelOptionsProduct } from '../model/product.ts';
 import type { IModelOptionsRole } from '../model/role.ts';
 import type { IModelOptionsRoleUser } from '../model/roleUser.ts';
 import type { IModelOptionsTest } from '../model/test.ts';
@@ -166,8 +196,12 @@ import 'vona';
 declare module 'vona-module-a-orm' {
     interface IModelRecord {
         'test-vona:category': IModelOptionsCategory;
+        'test-vona:categoryChain': IModelOptionsCategoryChain;
+        'test-vona:order': IModelOptionsOrder;
+        'test-vona:orderStats': IModelOptionsOrderStats;
         'test-vona:post': IModelOptionsPost;
         'test-vona:postContent': IModelOptionsPostContent;
+        'test-vona:product': IModelOptionsProduct;
         'test-vona:role': IModelOptionsRole;
         'test-vona:roleUser': IModelOptionsRoleUser;
         'test-vona:test': IModelOptionsTest;
@@ -184,6 +218,24 @@ declare module 'vona-module-test-vona' {
         get $beanFullName(): 'test-vona.model.category';
         get $onionName(): 'test-vona:category';
     }
+    interface ModelCategoryChain {
+    }
+    interface ModelCategoryChain {
+        get $beanFullName(): 'test-vona.model.categoryChain';
+        get $onionName(): 'test-vona:categoryChain';
+    }
+    interface ModelOrder {
+    }
+    interface ModelOrder {
+        get $beanFullName(): 'test-vona.model.order';
+        get $onionName(): 'test-vona:order';
+    }
+    interface ModelOrderStats {
+    }
+    interface ModelOrderStats {
+        get $beanFullName(): 'test-vona.model.orderStats';
+        get $onionName(): 'test-vona:orderStats';
+    }
     interface ModelPost {
     }
     interface ModelPost {
@@ -196,6 +248,12 @@ declare module 'vona-module-test-vona' {
         get $beanFullName(): 'test-vona.model.postContent';
         get $onionName(): 'test-vona:postContent';
     }
+    interface ModelProduct {
+    }
+    interface ModelProduct {
+        get $beanFullName(): 'test-vona.model.product';
+        get $onionName(): 'test-vona:product';
+    }
     interface ModelRole {
     }
     interface ModelRole {
@@ -242,8 +300,12 @@ declare module 'vona-module-test-vona' {
 /** model: end */
 /** model: begin */
 import type { ModelCategory } from '../model/category.ts';
+import type { ModelCategoryChain } from '../model/categoryChain.ts';
+import type { ModelOrder } from '../model/order.ts';
+import type { ModelOrderStats } from '../model/orderStats.ts';
 import type { ModelPost } from '../model/post.ts';
 import type { ModelPostContent } from '../model/postContent.ts';
+import type { ModelProduct } from '../model/product.ts';
 import type { ModelRole } from '../model/role.ts';
 import type { ModelRoleUser } from '../model/roleUser.ts';
 import type { ModelTest } from '../model/test.ts';
@@ -253,8 +315,12 @@ import type { ModelUserStats } from '../model/userStats.ts';
 import type { ModelUserStatsGroup } from '../model/userStatsGroup.ts';
 export interface IModuleModel {
     'category': ModelCategory;
+    'categoryChain': ModelCategoryChain;
+    'order': ModelOrder;
+    'orderStats': ModelOrderStats;
     'post': ModelPost;
     'postContent': ModelPostContent;
+    'product': ModelProduct;
     'role': ModelRole;
     'roleUser': ModelRoleUser;
     'test': ModelTest;
@@ -273,6 +339,29 @@ declare module 'vona-module-test-vona' {
             children: IModelRelationHasMany<ModelCategory, true, 'id' | 'name', undefined, undefined, undefined>;
         };
     }
+    interface IModelOptionsCategoryChain {
+        relations: {
+            parent: IModelRelationBelongsTo<ModelCategoryChain, ModelCategoryChain, true, 'id' | 'name' | 'categoryIdParent'>;
+        };
+    }
+    interface IModelOptionsOrder {
+        relations: {
+            user: IModelRelationBelongsTo<ModelOrder, ModelUser, true, 'id' | 'name'>;
+            products: IModelRelationHasMany<ModelProduct, true, 'id' | 'name' | 'price' | 'quantity' | 'amount', undefined, undefined, undefined>;
+        };
+    }
+    interface IModelOptionsOrderStats {
+        relations: {
+            productStats: IModelRelationHasMany<ModelProduct, true, '*', undefined, {
+                count?: '*' | Array<'*'>;
+                sum?: 'amount' | Array<'amount'>;
+            }, undefined>;
+            productsGroups: IModelRelationHasMany<ModelProduct, false, undefined, undefined, {
+                count?: '*' | Array<'*'>;
+                sum?: 'amount' | Array<'amount'>;
+            }, 'id' | Array<'id'>>;
+        };
+    }
     interface IModelOptionsPost {
         relations: {
             postContent: IModelRelationHasOne<'test-vona:postContent', false, 'id' | 'content'>;
@@ -336,6 +425,63 @@ declare module 'vona-module-test-vona' {
         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 ModelCategoryChain {
+        [SymbolKeyEntity]: EntityCategory;
+        [SymbolKeyEntityMeta]: EntityCategoryMeta;
+        [SymbolKeyModelOptions]: IModelOptionsCategoryChain;
+        get<T extends IModelGetOptions<EntityCategory, ModelCategoryChain>>(where: TypeModelWhere<EntityCategory>, options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategoryChain, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityCategory, ModelCategoryChain>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategoryChain, T>[]>;
+        select<T extends IModelSelectParams<EntityCategory, ModelCategoryChain, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityCategory, ModelCategoryChain, T>[]>;
+        insert<T extends IModelInsertOptions<EntityCategory, ModelCategoryChain>>(data?: TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityCategory, ModelCategoryChain>>(items: TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityCategory, ModelCategoryChain>>(data: TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityCategory, ModelCategoryChain>>(items: TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityCategory, ModelCategoryChain>>(where?: TypeModelWhere<EntityCategory>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityCategory, ModelCategoryChain>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityCategory, ModelCategoryChain>>(data?: TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityCategory, ModelCategoryChain>>(items: TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory, ModelCategoryChain, T>[]>;
+        count<T extends IModelSelectCountParams<EntityCategory, ModelCategoryChain, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityCategory, ModelCategoryChain, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityCategory, ModelCategoryChain, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityCategory, T>[]>;
+    }
+    interface ModelOrder {
+        [SymbolKeyEntity]: EntityOrder;
+        [SymbolKeyEntityMeta]: EntityOrderMeta;
+        [SymbolKeyModelOptions]: IModelOptionsOrder;
+        get<T extends IModelGetOptions<EntityOrder, ModelOrder>>(where: TypeModelWhere<EntityOrder>, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityOrder, ModelOrder>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T>[]>;
+        select<T extends IModelSelectParams<EntityOrder, ModelOrder, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T>[]>;
+        insert<T extends IModelInsertOptions<EntityOrder, ModelOrder>>(data?: TypeModelMutateRelationData<EntityOrder, ModelOrder, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityOrder, ModelOrder, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityOrder, ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder, ModelOrder, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityOrder, ModelOrder, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityOrder, ModelOrder>>(data: TypeModelMutateRelationData<EntityOrder, ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrder, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityOrder, ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder, ModelOrder, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrder, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityOrder, ModelOrder>>(where?: TypeModelWhere<EntityOrder>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityOrder, ModelOrder>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityOrder, ModelOrder>>(data?: TypeModelMutateRelationData<EntityOrder, ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrder, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityOrder, ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder, ModelOrder, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrder, T>[]>;
+        count<T extends IModelSelectCountParams<EntityOrder, ModelOrder, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityOrder, ModelOrder, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityOrder, ModelOrder, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityOrder, T>[]>;
+    }
+    interface ModelOrderStats {
+        [SymbolKeyEntity]: EntityOrder;
+        [SymbolKeyEntityMeta]: EntityOrderMeta;
+        [SymbolKeyModelOptions]: IModelOptionsOrderStats;
+        get<T extends IModelGetOptions<EntityOrder, ModelOrderStats>>(where: TypeModelWhere<EntityOrder>, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrderStats, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityOrder, ModelOrderStats>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrderStats, T>[]>;
+        select<T extends IModelSelectParams<EntityOrder, ModelOrderStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityOrder, ModelOrderStats, T>[]>;
+        insert<T extends IModelInsertOptions<EntityOrder, ModelOrderStats>>(data?: TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityOrder, ModelOrderStats>>(items: TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityOrder, ModelOrderStats>>(data: TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityOrder, ModelOrderStats>>(items: TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityOrder, ModelOrderStats>>(where?: TypeModelWhere<EntityOrder>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityOrder, ModelOrderStats>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityOrder, ModelOrderStats>>(data?: TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityOrder, ModelOrderStats>>(items: TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder, ModelOrderStats, T>[]>;
+        count<T extends IModelSelectCountParams<EntityOrder, ModelOrderStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityOrder, ModelOrderStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityOrder, ModelOrderStats, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityOrder, T>[]>;
+    }
     interface ModelPost {
         [SymbolKeyEntity]: EntityPost;
         [SymbolKeyEntityMeta]: EntityPostMeta;
@@ -374,6 +520,25 @@ declare module 'vona-module-test-vona' {
         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 ModelProduct {
+        [SymbolKeyEntity]: EntityProduct;
+        [SymbolKeyEntityMeta]: EntityProductMeta;
+        [SymbolKeyModelOptions]: IModelOptionsProduct;
+        get<T extends IModelGetOptions<EntityProduct, ModelProduct>>(where: TypeModelWhere<EntityProduct>, options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityProduct, ModelProduct>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T>[]>;
+        select<T extends IModelSelectParams<EntityProduct, ModelProduct, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T>[]>;
+        insert<T extends IModelInsertOptions<EntityProduct, ModelProduct>>(data?: TypeModelMutateRelationData<EntityProduct, ModelProduct, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityProduct, ModelProduct, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityProduct, ModelProduct>>(items: TypeModelMutateRelationData<EntityProduct, ModelProduct, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityProduct, ModelProduct, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityProduct, ModelProduct>>(data: TypeModelMutateRelationData<EntityProduct, ModelProduct, T>, options?: T): Promise<TypeModelMutateRelationData<EntityProduct, ModelProduct, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityProduct, ModelProduct>>(items: TypeModelMutateRelationData<EntityProduct, ModelProduct, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityProduct, ModelProduct, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityProduct, ModelProduct>>(where?: TypeModelWhere<EntityProduct>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityProduct, ModelProduct>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityProduct, ModelProduct>>(data?: TypeModelMutateRelationData<EntityProduct, ModelProduct, T>, options?: T): Promise<TypeModelMutateRelationData<EntityProduct, ModelProduct, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityProduct, ModelProduct>>(items: TypeModelMutateRelationData<EntityProduct, ModelProduct, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityProduct, ModelProduct, T>[]>;
+        count<T extends IModelSelectCountParams<EntityProduct, ModelProduct, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityProduct, ModelProduct, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityProduct, ModelProduct, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityProduct, T>[]>;
+    }
     interface ModelRole {
         [SymbolKeyEntity]: EntityRole;
         [SymbolKeyEntityMeta]: EntityRoleMeta;
@@ -511,8 +676,12 @@ declare module 'vona-module-test-vona' {
 declare module 'vona-module-a-orm' {
     interface IModelClassRecord {
         'test-vona:category': ModelCategory;
+        'test-vona:categoryChain': ModelCategoryChain;
+        'test-vona:order': ModelOrder;
+        'test-vona:orderStats': ModelOrderStats;
         'test-vona:post': ModelPost;
         'test-vona:postContent': ModelPostContent;
+        'test-vona:product': ModelProduct;
         'test-vona:role': ModelRole;
         'test-vona:roleUser': ModelRoleUser;
         'test-vona:test': ModelTest;
@@ -844,6 +1013,9 @@ export interface IModuleSummerCache {
 /** summerCache: end */
 /** dto: begin */
 export * from '../dto/categoryTree.ts';
+export * from '../dto/orderCreate.ts';
+export * from '../dto/orderResult.ts';
+export * from '../dto/orderUpdate.ts';
 export * from '../dto/postCreate.ts';
 export * from '../dto/profile.ts';
 export * from '../dto/roleLazy.ts';
@@ -852,6 +1024,9 @@ export * from '../dto/userCreate.ts';
 export * from '../dto/userLazy.ts';
 export * from '../dto/userUpdate.ts';
 import type { IDtoOptionsCategoryTree } from '../dto/categoryTree.ts';
+import type { IDtoOptionsOrderCreate } from '../dto/orderCreate.ts';
+import type { IDtoOptionsOrderResult } from '../dto/orderResult.ts';
+import type { IDtoOptionsOrderUpdate } from '../dto/orderUpdate.ts';
 import type { IDtoOptionsPostCreate } from '../dto/postCreate.ts';
 import type { IDtoOptionsProfile } from '../dto/profile.ts';
 import type { IDtoOptionsRoleLazy } from '../dto/roleLazy.ts';
@@ -863,6 +1038,9 @@ import 'vona';
 declare module 'vona-module-a-web' {
     interface IDtoRecord {
         'test-vona:categoryTree': IDtoOptionsCategoryTree;
+        'test-vona:orderCreate': IDtoOptionsOrderCreate;
+        'test-vona:orderResult': IDtoOptionsOrderResult;
+        'test-vona:orderUpdate': IDtoOptionsOrderUpdate;
         'test-vona:postCreate': IDtoOptionsPostCreate;
         'test-vona:profile': IDtoOptionsProfile;
         'test-vona:roleLazy': IDtoOptionsRoleLazy;
@@ -877,6 +1055,9 @@ declare module 'vona-module-test-vona' {
 /** dto: end */
 /** dto: begin */
 import type { DtoCategoryTree } from '../dto/categoryTree.ts';
+import type { DtoOrderCreate } from '../dto/orderCreate.ts';
+import type { DtoOrderResult } from '../dto/orderResult.ts';
+import type { DtoOrderUpdate } from '../dto/orderUpdate.ts';
 import type { DtoPostCreate } from '../dto/postCreate.ts';
 import type { DtoProfile } from '../dto/profile.ts';
 import type { DtoRoleLazy } from '../dto/roleLazy.ts';
@@ -888,6 +1069,15 @@ declare module 'vona-module-test-vona' {
     interface IDtoOptionsCategoryTree {
         fields?: TypeEntityOptionsFields<DtoCategoryTree, IDtoOptionsCategoryTree[TypeSymbolKeyFieldsMore]>;
     }
+    interface IDtoOptionsOrderCreate {
+        fields?: TypeEntityOptionsFields<DtoOrderCreate, IDtoOptionsOrderCreate[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsOrderResult {
+        fields?: TypeEntityOptionsFields<DtoOrderResult, IDtoOptionsOrderResult[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsOrderUpdate {
+        fields?: TypeEntityOptionsFields<DtoOrderUpdate, IDtoOptionsOrderUpdate[TypeSymbolKeyFieldsMore]>;
+    }
     interface IDtoOptionsPostCreate {
         fields?: TypeEntityOptionsFields<DtoPostCreate, IDtoOptionsPostCreate[TypeSymbolKeyFieldsMore]>;
     }
@@ -1144,6 +1334,7 @@ export * from '../config/config.ts';
 import type { config } from '../config/config.ts';
 export declare const locales: {
     'en-us': {
+        Name: string;
         User: string;
         UserId: string;
         Test: string;
@@ -1154,8 +1345,15 @@ export declare const locales: {
         TestNameApples_: string;
         TestNameApples_0_1: string;
         TestNameApples_1_1: string;
+        Order: string;
+        OrderNo: string;
+        Remark: string;
+        Price: string;
+        Quantity: string;
+        Amount: string;
     };
     'zh-cn': {
+        Name: string;
         User: string;
         UserId: string;
         Test: string;
@@ -1164,6 +1362,12 @@ export declare const locales: {
         TestApples_0: string;
         TestNameApples_: string;
         TestNameApples_0_1: string;
+        Order: string;
+        OrderNo: string;
+        Remark: string;
+        Price: string;
+        Quantity: string;
+        Amount: string;
     };
 };
 /** locale: end */

package/dist/config/locale/en-us.d.ts

@@ -1,4 +1,5 @@
 declare const _default: {
+    Name: string;
     User: string;
     UserId: string;
     Test: string;
@@ -9,5 +10,11 @@ declare const _default: {
     TestNameApples_: string;
     TestNameApples_0_1: string;
     TestNameApples_1_1: string;
+    Order: string;
+    OrderNo: string;
+    Remark: string;
+    Price: string;
+    Quantity: string;
+    Amount: string;
 };
 export default _default;

package/dist/config/locale/zh-cn.d.ts

@@ -1,4 +1,5 @@
 declare const _default: {
+    Name: string;
     User: string;
     UserId: string;
     Test: string;
@@ -7,5 +8,11 @@ declare const _default: {
     TestApples_0: string;
     TestNameApples_: string;
     TestNameApples_0_1: string;
+    Order: string;
+    OrderNo: string;
+    Remark: string;
+    Price: string;
+    Quantity: string;
+    Amount: string;
 };
 export default _default;

package/dist/controller/dtoTest.d.ts

@@ -19,8 +19,8 @@ export declare class ControllerDtoTest extends BeanBase {
     }>>;
     getCategoryTree(): Promise<import("vona-module-a-orm").TypeModelRelationResult_Normal<import("vona-module-test-vona").EntityCategory, import("vona-module-test-vona").ModelCategory, {
         columns: ("name" | "id")[];
-    }, undefined>[]>;
+    }, undefined, 50>[]>;
     getCategoryTree2(): Promise<import("vona-module-a-orm").TypeModelRelationResult_Normal<import("vona-module-test-vona").EntityCategory, import("vona-module-test-vona").ModelCategory, {
         columns: ("name" | "id")[];
-    }, undefined>[]>;
+    }, undefined, 50>[]>;
 }

package/dist/dto/orderCreate.d.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { ModelOrder } from '../model/order.ts';
+export interface IDtoOptionsOrderCreate extends IDecoratorDtoOptions {
+}
+declare const DtoOrderCreate_base: import("vona-core").Constructable<import("vona-module-a-orm").TypeDtoMutateResult<ModelOrder, {
+    columns: ("orderNo" | "remark")[];
+}, "create", "iid" | "id" | "createdAt" | "updatedAt" | "deleted", true>>;
+export declare class DtoOrderCreate extends DtoOrderCreate_base {
+}
+export {};

package/dist/dto/orderResult.d.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { ModelOrder } from '../model/order.ts';
+export interface IDtoOptionsOrderResult extends IDecoratorDtoOptions {
+}
+declare const DtoOrderResult_base: import("vona-core").Constructable<import("vona-module-a-orm").TypeDtoGetResult<ModelOrder, undefined>>;
+export declare class DtoOrderResult extends DtoOrderResult_base {
+}
+export {};

package/dist/dto/orderUpdate.d.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { ModelOrder } from '../model/order.ts';
+export interface IDtoOptionsOrderUpdate extends IDecoratorDtoOptions {
+}
+declare const DtoOrderUpdate_base: import("vona-core").Constructable<import("vona-module-a-orm").TypeDtoMutateResult<ModelOrder, {
+    columns: ("orderNo" | "remark")[];
+}, "update", "iid" | "id" | "createdAt" | "updatedAt" | "deleted", true>>;
+export declare class DtoOrderUpdate extends DtoOrderUpdate_base {
+}
+export {};

package/dist/entity/category.d.ts

@@ -4,5 +4,5 @@ export interface IEntityOptionsCategory extends IDecoratorEntityOptions {
 }
 export declare class EntityCategory extends EntityBase {
     name: string;
-    categoryIdParent: TableIdentity;
+    categoryIdParent?: TableIdentity;
 }

package/dist/entity/order.d.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { EntityBase } from 'vona-module-a-orm';
+import '../.metadata/index.ts';
+export interface IEntityOptionsOrder extends IDecoratorEntityOptions {
+}
+export declare class EntityOrder extends EntityBase {
+    orderNo: string;
+    remark?: string;
+    userId: TableIdentity;
+}

package/dist/entity/product.d.ts

@@ -0,0 +1,12 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { EntityBase } from 'vona-module-a-orm';
+import '../.metadata/index.ts';
+export interface IEntityOptionsProduct extends IDecoratorEntityOptions {
+}
+export declare class EntityProduct extends EntityBase {
+    name: string;
+    price: number;
+    quantity: number;
+    amount: number;
+    orderId: TableIdentity;
+}