vona-module-test-vona 5.0.52 → 5.0.54

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

@@ -358,7 +358,7 @@ import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'von
 declare module 'vona-module-test-vona' {
     interface IModelOptionsCategory {
         relations: {
-            children: IModelRelationHasMany<ModelCategory, true, 'id' | 'name', undefined, undefined, undefined>;
+            children: IModelRelationHasMany<ModelCategory, 'categoryIdParent', true, 'id' | 'name', undefined, undefined, undefined>;
         };
     }
     interface IModelOptionsCategoryChain {
@@ -369,16 +369,16 @@ declare module 'vona-module-test-vona' {
     interface IModelOptionsOrder {
         relations: {
             user: IModelRelationBelongsTo<ModelOrder, ModelUser, true, 'id' | 'name'>;
-            products: IModelRelationHasMany<ModelProduct, true, 'id' | 'name' | 'price' | 'quantity' | 'amount', undefined, undefined, undefined>;
+            products: IModelRelationHasMany<ModelProduct, 'orderId', true, 'id' | 'name' | 'price' | 'quantity' | 'amount', undefined, undefined, undefined>;
         };
     }
     interface IModelOptionsOrderStats {
         relations: {
-            productStats: IModelRelationHasMany<ModelProduct, true, '*', undefined, {
+            productStats: IModelRelationHasMany<ModelProduct, 'orderId', true, undefined, undefined, {
                 count?: '*' | Array<'*'>;
                 sum?: 'amount' | Array<'amount'>;
             }, undefined>;
-            productsGroups: IModelRelationHasMany<ModelProduct, false, undefined, undefined, {
+            productsGroups: IModelRelationHasMany<ModelProduct, 'orderId', false, undefined, undefined, {
                 count?: '*' | Array<'*'>;
                 sum?: 'amount' | Array<'amount'>;
             }, 'id' | Array<'id'>>;
@@ -386,13 +386,13 @@ declare module 'vona-module-test-vona' {
     }
     interface IModelOptionsPost {
         relations: {
-            postContent: IModelRelationHasOne<ModelPostContent, false, 'id' | 'content'>;
+            postContent: IModelRelationHasOne<ModelPostContent, 'postId', false, 'id' | 'content'>;
             user: IModelRelationBelongsTo<ModelPost, ModelUser, true, 'id' | 'name'>;
         };
     }
     interface IModelOptionsPostContent {
         relations: {
-            post: IModelRelationBelongsTo<ModelPostContent, ModelPost, false, '*'>;
+            post: IModelRelationBelongsTo<ModelPostContent, ModelPost, false, undefined>;
         };
     }
     interface IModelOptionsRole {
@@ -402,24 +402,24 @@ declare module 'vona-module-test-vona' {
     }
     interface IModelOptionsUser {
         relations: {
-            posts: IModelRelationHasMany<ModelPost, false, 'id' | 'title', ['test-vona:user', ModelPostContent], undefined, undefined>;
+            posts: IModelRelationHasMany<ModelPost, 'userId', 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, {
+            posts: IModelRelationHasMany<ModelPost, 'userId', true, undefined, undefined, {
                 count?: '*' | 'title' | Array<'*' | 'title'>;
                 sum?: 'stars' | Array<'stars'>;
             }, undefined>;
-            roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, '*', undefined, {
+            roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, undefined, undefined, {
                 count?: '*' | Array<'*'>;
             }, undefined>;
         };
     }
     interface IModelOptionsUserStatsGroup {
         relations: {
-            posts: IModelRelationHasMany<ModelPost, true, undefined, undefined, {
+            posts: IModelRelationHasMany<ModelPost, 'userId', true, undefined, undefined, {
                 count?: '*' | 'title' | Array<'*' | 'title'>;
                 sum?: 'stars' | Array<'stars'>;
             }, 'title' | Array<'title'>>;
@@ -1089,6 +1089,24 @@ declare module 'vona-module-test-vona' {
     }
 }
 /** schedule: end */
+/** serializerTransform: begin */
+export * from '../bean/serializerTransform.email.ts';
+import type { ISerializerTransformOptionsEmail } from '../bean/serializerTransform.email.ts';
+import 'vona';
+declare module 'vona-module-a-serialization' {
+    interface ISerializerTransformRecord {
+        'test-vona:email': ISerializerTransformOptionsEmail;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface SerializerTransformEmail {
+    }
+    interface SerializerTransformEmail {
+        get $beanFullName(): 'test-vona.serializerTransform.email';
+        get $onionName(): 'test-vona:email';
+    }
+}
+/** serializerTransform: end */
 /** summerCache: begin */
 export * from '../bean/summerCache.test.ts';
 import { type IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
@@ -1120,11 +1138,16 @@ export * from '../dto/orderQueryPage.ts';
 export * from '../dto/orderResult.ts';
 export * from '../dto/orderResultPage.ts';
 export * from '../dto/orderUpdate.ts';
+export * from '../dto/postAggregate.ts';
 export * from '../dto/postCreate.ts';
+export * from '../dto/postGroup.ts';
 export * from '../dto/postQuery.ts';
 export * from '../dto/postQueryRes.ts';
 export * from '../dto/profile.ts';
 export * from '../dto/roleLazy.ts';
+export * from '../dto/serializerArray.ts';
+export * from '../dto/serializerLazy.ts';
+export * from '../dto/serializerSimple.ts';
 export * from '../dto/signin.ts';
 export * from '../dto/user.ts';
 export * from '../dto/userCreate.ts';
@@ -1137,11 +1160,16 @@ import type { IDtoOptionsOrderQueryPage } from '../dto/orderQueryPage.ts';
 import type { IDtoOptionsOrderResult } from '../dto/orderResult.ts';
 import type { IDtoOptionsOrderResultPage } from '../dto/orderResultPage.ts';
 import type { IDtoOptionsOrderUpdate } from '../dto/orderUpdate.ts';
+import type { IDtoOptionsPostAggregate } from '../dto/postAggregate.ts';
 import type { IDtoOptionsPostCreate } from '../dto/postCreate.ts';
+import type { IDtoOptionsPostGroup } from '../dto/postGroup.ts';
 import type { IDtoOptionsPostQuery } from '../dto/postQuery.ts';
 import type { IDtoOptionsPostQueryRes } from '../dto/postQueryRes.ts';
 import type { IDtoOptionsProfile } from '../dto/profile.ts';
 import type { IDtoOptionsRoleLazy } from '../dto/roleLazy.ts';
+import type { IDtoOptionsSerializerArray } from '../dto/serializerArray.ts';
+import type { IDtoOptionsSerializerLazy } from '../dto/serializerLazy.ts';
+import type { IDtoOptionsSerializerSimple } from '../dto/serializerSimple.ts';
 import type { IDtoOptionsSignin } from '../dto/signin.ts';
 import type { IDtoOptionsUser } from '../dto/user.ts';
 import type { IDtoOptionsUserCreate } from '../dto/userCreate.ts';
@@ -1157,11 +1185,16 @@ declare module 'vona-module-a-web' {
         'test-vona:orderResult': IDtoOptionsOrderResult;
         'test-vona:orderResultPage': IDtoOptionsOrderResultPage;
         'test-vona:orderUpdate': IDtoOptionsOrderUpdate;
+        'test-vona:postAggregate': IDtoOptionsPostAggregate;
         'test-vona:postCreate': IDtoOptionsPostCreate;
+        'test-vona:postGroup': IDtoOptionsPostGroup;
         'test-vona:postQuery': IDtoOptionsPostQuery;
         'test-vona:postQueryRes': IDtoOptionsPostQueryRes;
         'test-vona:profile': IDtoOptionsProfile;
         'test-vona:roleLazy': IDtoOptionsRoleLazy;
+        'test-vona:serializerArray': IDtoOptionsSerializerArray;
+        'test-vona:serializerLazy': IDtoOptionsSerializerLazy;
+        'test-vona:serializerSimple': IDtoOptionsSerializerSimple;
         'test-vona:signin': IDtoOptionsSignin;
         'test-vona:user': IDtoOptionsUser;
         'test-vona:userCreate': IDtoOptionsUserCreate;
@@ -1180,11 +1213,16 @@ import type { DtoOrderQueryPage } from '../dto/orderQueryPage.ts';
 import type { DtoOrderResult } from '../dto/orderResult.ts';
 import type { DtoOrderResultPage } from '../dto/orderResultPage.ts';
 import type { DtoOrderUpdate } from '../dto/orderUpdate.ts';
+import type { DtoPostAggregate } from '../dto/postAggregate.ts';
 import type { DtoPostCreate } from '../dto/postCreate.ts';
+import type { DtoPostGroup } from '../dto/postGroup.ts';
 import type { DtoPostQuery } from '../dto/postQuery.ts';
 import type { DtoPostQueryRes } from '../dto/postQueryRes.ts';
 import type { DtoProfile } from '../dto/profile.ts';
 import type { DtoRoleLazy } from '../dto/roleLazy.ts';
+import type { DtoSerializerArray } from '../dto/serializerArray.ts';
+import type { DtoSerializerLazy } from '../dto/serializerLazy.ts';
+import type { DtoSerializerSimple } from '../dto/serializerSimple.ts';
 import type { DtoSignin } from '../dto/signin.ts';
 import type { DtoUser } from '../dto/user.ts';
 import type { DtoUserCreate } from '../dto/userCreate.ts';
@@ -1212,9 +1250,15 @@ declare module 'vona-module-test-vona' {
     interface IDtoOptionsOrderUpdate {
         fields?: TypeEntityOptionsFields<DtoOrderUpdate, IDtoOptionsOrderUpdate[TypeSymbolKeyFieldsMore]>;
     }
+    interface IDtoOptionsPostAggregate {
+        fields?: TypeEntityOptionsFields<DtoPostAggregate, IDtoOptionsPostAggregate[TypeSymbolKeyFieldsMore]>;
+    }
     interface IDtoOptionsPostCreate {
         fields?: TypeEntityOptionsFields<DtoPostCreate, IDtoOptionsPostCreate[TypeSymbolKeyFieldsMore]>;
     }
+    interface IDtoOptionsPostGroup {
+        fields?: TypeEntityOptionsFields<DtoPostGroup, IDtoOptionsPostGroup[TypeSymbolKeyFieldsMore]>;
+    }
     interface IDtoOptionsPostQuery {
         fields?: TypeEntityOptionsFields<DtoPostQuery, IDtoOptionsPostQuery[TypeSymbolKeyFieldsMore]>;
     }
@@ -1227,6 +1271,15 @@ declare module 'vona-module-test-vona' {
     interface IDtoOptionsRoleLazy {
         fields?: TypeEntityOptionsFields<DtoRoleLazy, IDtoOptionsRoleLazy[TypeSymbolKeyFieldsMore]>;
     }
+    interface IDtoOptionsSerializerArray {
+        fields?: TypeEntityOptionsFields<DtoSerializerArray, IDtoOptionsSerializerArray[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsSerializerLazy {
+        fields?: TypeEntityOptionsFields<DtoSerializerLazy, IDtoOptionsSerializerLazy[TypeSymbolKeyFieldsMore]>;
+    }
+    interface IDtoOptionsSerializerSimple {
+        fields?: TypeEntityOptionsFields<DtoSerializerSimple, IDtoOptionsSerializerSimple[TypeSymbolKeyFieldsMore]>;
+    }
     interface IDtoOptionsSignin {
         fields?: TypeEntityOptionsFields<DtoSignin, IDtoOptionsSignin[TypeSymbolKeyFieldsMore]>;
     }
@@ -1257,6 +1310,7 @@ export * from '../controller/passport.ts';
 export * from '../controller/performAction.ts';
 export * from '../controller/post.ts';
 export * from '../controller/queue.ts';
+export * from '../controller/serializer.ts';
 export * from '../controller/summer.ts';
 export * from '../controller/tail.ts';
 export * from '../controller/transaction.ts';
@@ -1273,6 +1327,7 @@ import type { IControllerOptionsPassport } from '../controller/passport.ts';
 import type { IControllerOptionsPerformAction } from '../controller/performAction.ts';
 import type { IControllerOptionsPost } from '../controller/post.ts';
 import type { IControllerOptionsQueue } from '../controller/queue.ts';
+import type { IControllerOptionsSerializer } from '../controller/serializer.ts';
 import type { IControllerOptionsSummer } from '../controller/summer.ts';
 import type { IControllerOptionsTail } from '../controller/tail.ts';
 import type { IControllerOptionsTransaction } from '../controller/transaction.ts';
@@ -1292,6 +1347,7 @@ declare module 'vona-module-a-web' {
         'test-vona:performAction': IControllerOptionsPerformAction;
         'test-vona:post': IControllerOptionsPost;
         'test-vona:queue': IControllerOptionsQueue;
+        'test-vona:serializer': IControllerOptionsSerializer;
         'test-vona:summer': IControllerOptionsSummer;
         'test-vona:tail': IControllerOptionsTail;
         'test-vona:transaction': IControllerOptionsTransaction;
@@ -1371,6 +1427,12 @@ declare module 'vona-module-test-vona' {
         get $beanFullName(): 'test-vona.controller.queue';
         get $onionName(): 'test-vona:queue';
     }
+    interface ControllerSerializer {
+    }
+    interface ControllerSerializer {
+        get $beanFullName(): 'test-vona.controller.serializer';
+        get $onionName(): 'test-vona:serializer';
+    }
     interface ControllerSummer {
     }
     interface ControllerSummer {
@@ -1410,6 +1472,7 @@ import '../controller/passport.ts';
 import '../controller/performAction.ts';
 import '../controller/post.ts';
 import '../controller/queue.ts';
+import '../controller/serializer.ts';
 import '../controller/summer.ts';
 import '../controller/tail.ts';
 import '../controller/transaction.ts';
@@ -1451,6 +1514,9 @@ declare module 'vona-module-test-vona' {
     interface IControllerOptionsQueue {
         actions?: TypeControllerOptionsActions<ControllerQueue>;
     }
+    interface IControllerOptionsSerializer {
+        actions?: TypeControllerOptionsActions<ControllerSerializer>;
+    }
     interface IControllerOptionsSummer {
         actions?: TypeControllerOptionsActions<ControllerSummer>;
     }
@@ -1486,6 +1552,8 @@ declare module 'vona-module-a-web' {
         '/test/vona/order/findMany': undefined;
         '/test/vona/passport/echo/:name': undefined;
         '/test/vona/passport/isAuthenticated': undefined;
+        '/test/vona/post/group': undefined;
+        '/test/vona/post/aggregate': undefined;
         '/test/vona/post/findManyEcho': undefined;
         '/test/vona/post/findMany': undefined;
     }
@@ -1498,12 +1566,16 @@ declare module 'vona-module-a-web' {
         '/test/vona/onion/echo2/:userId/:userName': undefined;
         '/test/vona/onion/echo4': undefined;
         '/test/vona/order/create': undefined;
+        '/test/vona/order/update/:id': undefined;
         '/test/vona/passport/login': undefined;
         '/test/vona/passport/refresh': undefined;
         '/test/vona/passport/logout': undefined;
         '/test/vona/performAction/echo': undefined;
         '/test/vona/queue/pushAsync': undefined;
         '/test/vona/queue/push': undefined;
+        '/test/vona/serializer/echoSimple': undefined;
+        '/test/vona/serializer/echoArray': undefined;
+        '/test/vona/serializer/echoLazy': undefined;
         '/test/vona/summer': undefined;
         '/test/vona/tail': undefined;
         '/test/vona/transaction/fail': undefined;

package/dist/bean/serializerTransform.email.d.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorSerializerTransformOptions, ISerializerTransform } from 'vona-module-a-serialization';
+import { BeanBase } from 'vona';
+export type TypeSerializerTransformEmailValue = string | undefined;
+export type TypeSerializerTransformEmailData = unknown;
+export type TypeSerializerTransformEmailResult = TypeSerializerTransformEmailValue;
+export interface ISerializerTransformOptionsEmail extends IDecoratorSerializerTransformOptions {
+}
+export declare class SerializerTransformEmail extends BeanBase implements ISerializerTransform<TypeSerializerTransformEmailValue, TypeSerializerTransformEmailData, TypeSerializerTransformEmailResult> {
+    transform(value: TypeSerializerTransformEmailValue, _data: TypeSerializerTransformEmailData, _options: ISerializerTransformOptionsEmail): Promise<TypeSerializerTransformEmailResult>;
+}

package/dist/controller/order.d.ts

@@ -1,14 +1,75 @@
+import type { TableIdentity } from 'table-identity';
 import type { IQueryParams } from 'vona-module-a-orm';
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import type { ModelOrder } from '../model/order.ts';
 import { BeanBase } from 'vona';
 import { DtoOrderCreate } from '../dto/orderCreate.ts';
 import { DtoOrderResult } from '../dto/orderResult.ts';
-import { DtoOrderResultPage } from '../dto/orderResultPage.ts';
+import { DtoOrderUpdate } from '../dto/orderUpdate.ts';
 export interface IControllerOptionsOrder extends IDecoratorControllerOptions {
 }
 export declare class ControllerOrder extends BeanBase {
     create(data: DtoOrderCreate): Promise<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityOrder, ModelOrder, import("vona-module-a-orm").IModelInsertOptions<import("vona-module-test-vona").EntityOrder, ModelOrder>, true>>;
+    update(id: TableIdentity, data: DtoOrderUpdate): Promise<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityOrder, ModelOrder, import("vona-module-a-orm").IModelUpdateOptions<import("vona-module-test-vona").EntityOrder, ModelOrder>>>;
     findAll(params: IQueryParams<ModelOrder>): Promise<DtoOrderResult[]>;
-    findMany(params: IQueryParams<ModelOrder>): Promise<DtoOrderResultPage>;
+    findMany(params: IQueryParams<ModelOrder>): Promise<import("vona-module-a-orm").TypeModelSelectAndCount<import("vona-module-test-vona").EntityOrder, ModelOrder, {
+        include: {
+            products: true;
+        };
+        with?: Record<string, unknown>;
+        distinct?: boolean | keyof import("vona-module-test-vona").EntityOrder | (keyof import("vona-module-test-vona").EntityOrder)[] | undefined;
+        columns?: "id" | "iid" | "createdAt" | "updatedAt" | "deleted" | "*" | "userId" | "orderNo" | "remark" | ("id" | "iid" | "createdAt" | "updatedAt" | "deleted" | "*" | "userId" | "orderNo" | "remark")[] | undefined;
+        where?: import("vona-module-a-orm").TypeModelWhereInner<{
+            "testVonaProduct.name": string;
+            "testVonaProduct.price": number;
+            "testVonaProduct.quantity": number;
+            "testVonaProduct.amount": number;
+            "testVonaProduct.orderId": TableIdentity;
+            "testVonaProduct.id": TableIdentity;
+            "testVonaProduct.createdAt": Date;
+            "testVonaProduct.updatedAt": Date;
+            "testVonaProduct.deleted": boolean;
+            "testVonaProduct.iid": number;
+        } & {
+            "testVonaOrder.orderNo": string;
+            "testVonaOrder.remark"?: string | undefined;
+            "testVonaOrder.userId": TableIdentity;
+            "testVonaOrder.id": TableIdentity;
+            "testVonaOrder.createdAt": Date;
+            "testVonaOrder.updatedAt": Date;
+            "testVonaOrder.deleted": boolean;
+            "testVonaOrder.iid": number;
+        } & import("vona-module-test-vona").EntityOrder> | import("vona-module-a-orm").TypeModelWhereInner<{
+            "testVonaUser.name": string;
+            "testVonaUser.age"?: number | undefined;
+            "testVonaUser.scores"?: number | undefined;
+            "testVonaUser.id": TableIdentity;
+            "testVonaUser.createdAt": Date;
+            "testVonaUser.updatedAt": Date;
+            "testVonaUser.deleted": boolean;
+            "testVonaUser.iid": number;
+        } & {
+            "testVonaOrder.orderNo": string;
+            "testVonaOrder.remark"?: string | undefined;
+            "testVonaOrder.userId": TableIdentity;
+            "testVonaOrder.id": TableIdentity;
+            "testVonaOrder.createdAt": Date;
+            "testVonaOrder.updatedAt": Date;
+            "testVonaOrder.deleted": boolean;
+            "testVonaOrder.iid": number;
+        } & import("vona-module-test-vona").EntityOrder> | undefined;
+        joins?: import("vona-module-a-orm").IModelSelectParamsJoin<import("vona-module-test-vona").EntityOrder, import("vona").TypeRecordValues<{
+            user: "testVonaUser";
+            products: "testVonaProduct";
+        }>, import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelOrder> | import("vona").TypeRecordValues<{
+            user: "testVonaUser.name" | "testVonaUser.id" | "testVonaUser.iid" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.age" | "testVonaUser.scores";
+            products: "testVonaProduct.name" | "testVonaProduct.id" | "testVonaProduct.iid" | "testVonaProduct.createdAt" | "testVonaProduct.updatedAt" | "testVonaProduct.deleted" | "testVonaProduct.price" | "testVonaProduct.quantity" | "testVonaProduct.amount" | "testVonaProduct.orderId";
+        }>>[] | undefined;
+        orders?: import("vona-module-a-orm").IModelSelectParamsOrder<import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelOrder> | import("vona").TypeRecordValues<{
+            user: "testVonaUser.name" | "testVonaUser.id" | "testVonaUser.iid" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.age" | "testVonaUser.scores";
+            products: "testVonaProduct.name" | "testVonaProduct.id" | "testVonaProduct.iid" | "testVonaProduct.createdAt" | "testVonaProduct.updatedAt" | "testVonaProduct.deleted" | "testVonaProduct.price" | "testVonaProduct.quantity" | "testVonaProduct.amount" | "testVonaProduct.orderId";
+        }>>[] | undefined;
+        limit?: number;
+        offset?: number;
+    }, undefined, undefined, undefined, 50>>;
 }

package/dist/controller/post.d.ts

@@ -2,9 +2,13 @@ import type { IQueryParams } from 'vona-module-a-orm';
 import type { IDecoratorControllerOptions, IPipeOptionsQueryTransformInfo } from 'vona-module-a-web';
 import type { ModelPost } from '../model/post.ts';
 import { BeanBase } from 'vona';
+import { DtoPostAggregate } from '../dto/postAggregate.ts';
+import { DtoPostGroup } from '../dto/postGroup.ts';
 export interface IControllerOptionsPost extends IDecoratorControllerOptions {
 }
 export declare class ControllerPost extends BeanBase {
+    group(): Promise<DtoPostGroup[]>;
+    aggregate(): Promise<DtoPostAggregate>;
     findManyEcho(params: IQueryParams<ModelPost>): IQueryParams<ModelPost>;
     findManyQueryTransform(_info: IPipeOptionsQueryTransformInfo): boolean | undefined;
     findMany(params: IQueryParams<ModelPost>): Promise<import("vona-module-a-orm").TypeModelSelectAndCount<import("vona-module-test-vona").EntityPost, ModelPost, {
@@ -54,11 +58,11 @@ export declare class ControllerPost extends BeanBase {
             postContent: "testVonaPostContent";
             user: "testVonaUser";
         }>, import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelPost> | import("vona").TypeRecordValues<{
-            postContent: "testVonaPostContent.id" | "testVonaPostContent.content" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
+            postContent: "testVonaPostContent.content" | "testVonaPostContent.id" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
             user: "testVonaUser.name" | "testVonaUser.id" | "testVonaUser.iid" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.age" | "testVonaUser.scores";
         }>>[] | undefined;
         orders?: import("vona-module-a-orm").IModelSelectParamsOrder<import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelPost> | import("vona").TypeRecordValues<{
-            postContent: "testVonaPostContent.id" | "testVonaPostContent.content" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
+            postContent: "testVonaPostContent.content" | "testVonaPostContent.id" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
             user: "testVonaUser.name" | "testVonaUser.id" | "testVonaUser.iid" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.age" | "testVonaUser.scores";
         }>>[] | undefined;
         limit?: number;

package/dist/controller/serializer.d.ts

@@ -0,0 +1,12 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { DtoSerializerArray } from '../dto/serializerArray.ts';
+import { DtoSerializerLazy } from '../dto/serializerLazy.ts';
+import { DtoSerializerSimple } from '../dto/serializerSimple.ts';
+export interface IControllerOptionsSerializer extends IDecoratorControllerOptions {
+}
+export declare class ControllerSerializer extends BeanBase {
+    echoSimple(data: DtoSerializerSimple): DtoSerializerSimple;
+    echoArray(data: DtoSerializerArray[]): DtoSerializerArray[];
+    echoLazy(data: DtoSerializerLazy): DtoSerializerLazy;
+}

package/dist/dto/postAggregate.d.ts

@@ -0,0 +1,13 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+export interface IDtoOptionsPostAggregate extends IDecoratorDtoOptions {
+}
+declare const DtoPostAggregate_base: import("vona-core").Constructable<import("vona-module-a-orm").TypeRecordAggrsValuesToObject<import("vona-module-a-orm").TypeRecordAggrsValues<{
+    count: "count_all" | "count_stars";
+    sum: "sum_stars";
+    avg: "avg_stars";
+    min: "min_stars";
+    max: "max_stars";
+}>>>;
+export declare class DtoPostAggregate extends DtoPostAggregate_base {
+}
+export {};

package/dist/dto/postGroup.d.ts

@@ -0,0 +1,12 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+export interface IDtoOptionsPostGroup extends IDecoratorDtoOptions {
+}
+declare const DtoPostGroup_base: import("vona-core").Constructable<{
+    userId: import("table-identity").TableIdentity;
+} & import("vona-module-a-orm").TypeRecordAggrsValuesToObject<import("vona-module-a-orm").TypeRecordAggrsValues<{
+    count: "count_all";
+    sum: "sum_stars";
+}>>>;
+export declare class DtoPostGroup extends DtoPostGroup_base {
+}
+export {};

package/dist/dto/serializerArray.d.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { DtoSerializerSimple } from './serializerSimple.ts';
+export interface IDtoOptionsSerializerArray extends IDecoratorDtoOptions {
+}
+export declare class DtoSerializerArray {
+    simples: DtoSerializerSimple[];
+    simplesLazy: DtoSerializerSimple[];
+}

package/dist/dto/serializerLazy.d.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { DtoSerializerSimple } from './serializerSimple.ts';
+export interface IDtoOptionsSerializerLazy extends IDecoratorDtoOptions {
+}
+export declare class DtoSerializerLazy {
+    simple: DtoSerializerSimple;
+    simpleLazy: DtoSerializerSimple;
+}

package/dist/dto/serializerSimple.d.ts

@@ -0,0 +1,19 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+export interface IDtoOptionsSerializerSimple extends IDecoratorDtoOptions {
+}
+export declare class DtoSerializerSimple {
+    password: string;
+    password2: string;
+    email: string;
+    email2: string;
+    email3: string;
+    email4: string;
+    email5: string;
+    email6: string;
+    email7: string;
+    firstName: string;
+    lastName: string;
+    fullName: string;
+    fullName2: string;
+    get fullName3(): string;
+}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './.metadata/index.ts';
+export * from './lib/index.ts';