vona-module-test-vona 5.0.33 → 5.0.35

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]>;
     }
@@ -144,8 +166,11 @@ declare module 'vona-module-test-vona' {
 /** 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';
@@ -155,8 +180,11 @@ 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';
@@ -169,8 +197,11 @@ 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;
@@ -193,6 +224,18 @@ declare module 'vona-module-test-vona' {
         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 {
@@ -205,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 {
@@ -252,8 +301,11 @@ declare module 'vona-module-test-vona' {
 /** 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';
@@ -264,8 +316,11 @@ 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;
@@ -276,6 +331,27 @@ export interface IModuleModel {
 }
 /** model: end */
 /** model: begin */
+import 'vona';
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'test-vona.model.category': ModelCategory;
+        'test-vona.model.categoryChain': ModelCategoryChain;
+        'test-vona.model.order': ModelOrder;
+        'test-vona.model.orderStats': ModelOrderStats;
+        'test-vona.model.post': ModelPost;
+        'test-vona.model.postContent': ModelPostContent;
+        'test-vona.model.product': ModelProduct;
+        'test-vona.model.role': ModelRole;
+        'test-vona.model.roleUser': ModelRoleUser;
+        'test-vona.model.test': ModelTest;
+        'test-vona.model.testDynamicTable': ModelTestDynamicTable;
+        'test-vona.model.user': ModelUser;
+        'test-vona.model.userStats': ModelUserStats;
+        'test-vona.model.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' {
@@ -289,6 +365,24 @@ declare module 'vona-module-test-vona' {
             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'>;
@@ -371,6 +465,44 @@ declare module 'vona-module-test-vona' {
         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;
@@ -409,6 +541,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;
@@ -547,8 +698,11 @@ 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;
@@ -880,6 +1034,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';
@@ -888,6 +1045,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';
@@ -899,6 +1059,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;
@@ -913,6 +1076,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';
@@ -924,6 +1090,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]>;
     }
@@ -1180,6 +1355,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;
@@ -1190,8 +1366,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;
@@ -1200,6 +1383,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/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/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;
+}