vona-cli-set-api 1.0.113 → 1.0.117

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/.metadata/index.d.ts

@@ -1,19 +1,18 @@
-import type { TypeMetaEntity } from 'vona-module-a-database';
-import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';
-import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+import type { TypeEntityMeta, TypeModelsClassLikeGeneral, TypeSymbolKeyFieldsMore, IModelRelationBelongsToMany } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields, TypeControllerOptionsActions } from 'vona-module-a-openapi';
 /** entity: begin */
 export * from '../entity/role.ts';
+export * from '../entity/roleUser.ts';
 export * from '../entity/user.ts';
-export * from '../entity/userRole.ts';
 import type { IEntityOptionsRole } from '../entity/role.ts';
+import type { IEntityOptionsRoleUser } from '../entity/roleUser.ts';
 import type { IEntityOptionsUser } from '../entity/user.ts';
-import type { IEntityOptionsUserRole } from '../entity/userRole.ts';
 import 'vona';
-declare module 'vona-module-a-database' {
+declare module 'vona-module-a-orm' {
     interface IEntityRecord {
-        'home-user:role': Omit<IEntityOptionsRole, '_fieldsMore_'>;
-        'home-user:user': Omit<IEntityOptionsUser, '_fieldsMore_'>;
-        'home-user:userRole': Omit<IEntityOptionsUserRole, '_fieldsMore_'>;
+        'home-user:role': IEntityOptionsRole;
+        'home-user:roleUser': IEntityOptionsRoleUser;
+        'home-user:user': IEntityOptionsUser;
     }
 }
 declare module 'vona-module-home-user' {
@@ -21,66 +20,159 @@ declare module 'vona-module-home-user' {
 /** entity: end */
 /** entity: begin */
 import type { EntityRole } from '../entity/role.ts';
+import type { EntityRoleUser } from '../entity/roleUser.ts';
 import type { EntityUser } from '../entity/user.ts';
-import type { EntityUserRole } from '../entity/userRole.ts';
 export interface IModuleEntity {
-    'role': TypeMetaEntity<EntityRole, EntityRoleTableName>;
-    'user': TypeMetaEntity<EntityUser, EntityUserTableName>;
-    'userRole': TypeMetaEntity<EntityUserRole, EntityUserRoleTableName>;
+    'role': EntityRoleMeta;
+    'roleUser': EntityRoleUserMeta;
+    'user': EntityUserMeta;
 }
 /** entity: end */
 /** entity: begin */
 export type EntityRoleTableName = 'homeRole';
+export type EntityRoleUserTableName = 'homeRoleUser';
 export type EntityUserTableName = 'homeUser';
-export type EntityUserRoleTableName = 'homeUserRole';
-declare module 'vona-module-a-database' {
+export type EntityRoleMeta = TypeEntityMeta<EntityRole, EntityRoleTableName>;
+export type EntityRoleUserMeta = TypeEntityMeta<EntityRoleUser, EntityRoleUserTableName>;
+export type EntityUserMeta = TypeEntityMeta<EntityUser, EntityUserTableName>;
+declare module 'vona-module-a-orm' {
     interface ITableRecord {
         'homeRole': never;
+        'homeRoleUser': never;
         'homeUser': never;
-        'homeUserRole': never;
     }
 }
 declare module 'vona-module-home-user' {
     interface IEntityOptionsRole {
-        fields?: TypeEntityOptionsFields<EntityRole, IEntityOptionsRole['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<EntityRole, IEntityOptionsRole[TypeSymbolKeyFieldsMore]>;
     }
-    interface IEntityOptionsUser {
-        fields?: TypeEntityOptionsFields<EntityUser, IEntityOptionsUser['_fieldsMore_']>;
+    interface IEntityOptionsRoleUser {
+        fields?: TypeEntityOptionsFields<EntityRoleUser, IEntityOptionsRoleUser[TypeSymbolKeyFieldsMore]>;
     }
-    interface IEntityOptionsUserRole {
-        fields?: TypeEntityOptionsFields<EntityUserRole, IEntityOptionsUserRole['_fieldsMore_']>;
+    interface IEntityOptionsUser {
+        fields?: TypeEntityOptionsFields<EntityUser, IEntityOptionsUser[TypeSymbolKeyFieldsMore]>;
     }
 }
 /** entity: end */
 /** model: begin */
 export * from '../model/role.ts';
+export * from '../model/roleUser.ts';
 export * from '../model/user.ts';
-export * from '../model/userRole.ts';
-import { type IDecoratorModelOptions } from 'vona-module-a-database';
-declare module 'vona-module-a-database' {
+import type { IModelOptionsRole } from '../model/role.ts';
+import type { IModelOptionsRoleUser } from '../model/roleUser.ts';
+import type { IModelOptionsUser } from '../model/user.ts';
+import 'vona';
+declare module 'vona-module-a-orm' {
     interface IModelRecord {
-        'home-user:role': IDecoratorModelOptions;
-        'home-user:user': IDecoratorModelOptions;
-        'home-user:userRole': IDecoratorModelOptions;
+        'home-user:role': IModelOptionsRole;
+        'home-user:roleUser': IModelOptionsRoleUser;
+        'home-user:user': IModelOptionsUser;
     }
 }
 declare module 'vona-module-home-user' {
     interface ModelRole {
     }
+    interface ModelRole {
+        get $beanFullName(): 'home-user.model.role';
+        get $onionName(): 'home-user:role';
+    }
+    interface ModelRoleUser {
+    }
+    interface ModelRoleUser {
+        get $beanFullName(): 'home-user.model.roleUser';
+        get $onionName(): 'home-user:roleUser';
+    }
     interface ModelUser {
     }
-    interface ModelUserRole {
+    interface ModelUser {
+        get $beanFullName(): 'home-user.model.user';
+        get $onionName(): 'home-user:user';
     }
 }
 /** model: end */
 /** model: begin */
 import type { ModelRole } from '../model/role.ts';
+import type { ModelRoleUser } from '../model/roleUser.ts';
 import type { ModelUser } from '../model/user.ts';
-import type { ModelUserRole } from '../model/userRole.ts';
 export interface IModuleModel {
     'role': ModelRole;
+    'roleUser': ModelRoleUser;
     'user': ModelUser;
-    'userRole': ModelUserRole;
+}
+/** 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-home-user' {
+    interface IModelOptionsUser {
+        relations: {
+            roles: IModelRelationBelongsToMany<ModelRoleUser, ModelRole, false, 'id' | 'name', undefined, undefined, undefined>;
+        };
+    }
+    interface ModelRole {
+        [SymbolKeyEntity]: EntityRole;
+        [SymbolKeyEntityMeta]: EntityRoleMeta;
+        [SymbolKeyModelOptions]: IModelOptionsRole;
+        get<T extends IModelGetOptions<EntityRole, ModelRole>>(where: TypeModelWhere<EntityRole>, options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityRole, ModelRole>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
+        select<T extends IModelSelectParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
+        insert<T extends IModelInsertOptions<EntityRole, ModelRole>>(data?: TypeModelMutateRelationData<EntityRole, ModelRole, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityRole, ModelRole, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityRole, ModelRole>>(items: TypeModelMutateRelationData<EntityRole, ModelRole, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityRole, ModelRole, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityRole, ModelRole>>(data: TypeModelMutateRelationData<EntityRole, ModelRole, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityRole, ModelRole>>(items: TypeModelMutateRelationData<EntityRole, ModelRole, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityRole, ModelRole>>(where?: TypeModelWhere<EntityRole>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityRole, ModelRole>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityRole, ModelRole>>(data?: TypeModelMutateRelationData<EntityRole, ModelRole, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityRole, ModelRole>>(items: TypeModelMutateRelationData<EntityRole, ModelRole, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRole, ModelRole, T>[]>;
+        count<T extends IModelSelectCountParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityRole, ModelRole, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityRole, T>[]>;
+    }
+    interface ModelRoleUser {
+        [SymbolKeyEntity]: EntityRoleUser;
+        [SymbolKeyEntityMeta]: EntityRoleUserMeta;
+        [SymbolKeyModelOptions]: IModelOptionsRoleUser;
+        get<T extends IModelGetOptions<EntityRoleUser, ModelRoleUser>>(where: TypeModelWhere<EntityRoleUser>, options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityRoleUser, ModelRoleUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
+        select<T extends IModelSelectParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
+        insert<T extends IModelInsertOptions<EntityRoleUser, ModelRoleUser>>(data?: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityRoleUser, ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityRoleUser, ModelRoleUser>>(data: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityRoleUser, ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityRoleUser, ModelRoleUser>>(where?: TypeModelWhere<EntityRoleUser>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityRoleUser, ModelRoleUser>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityRoleUser, ModelRoleUser>>(data?: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityRoleUser, ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser, ModelRoleUser, T>[]>;
+        count<T extends IModelSelectCountParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityRoleUser, ModelRoleUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityRoleUser, T>[]>;
+    }
+    interface ModelUser {
+        [SymbolKeyEntity]: EntityUser;
+        [SymbolKeyEntityMeta]: EntityUserMeta;
+        [SymbolKeyModelOptions]: IModelOptionsUser;
+        get<T extends IModelGetOptions<EntityUser, ModelUser>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityUser, ModelUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
+        select<T extends IModelSelectParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
+        insert<T extends IModelInsertOptions<EntityUser, ModelUser>>(data?: TypeModelMutateRelationData<EntityUser, ModelUser, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUser, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityUser, ModelUser>>(items: TypeModelMutateRelationData<EntityUser, ModelUser, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityUser, ModelUser, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityUser, ModelUser>>(data: TypeModelMutateRelationData<EntityUser, ModelUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityUser, ModelUser>>(items: TypeModelMutateRelationData<EntityUser, ModelUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityUser, ModelUser>>(where?: TypeModelWhere<EntityUser>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityUser, ModelUser>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityUser, ModelUser>>(data?: TypeModelMutateRelationData<EntityUser, ModelUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityUser, ModelUser>>(items: TypeModelMutateRelationData<EntityUser, ModelUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser, ModelUser, T>[]>;
+        count<T extends IModelSelectCountParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityUser, ModelUser, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityUser, T>[]>;
+    }
+}
+declare module 'vona-module-a-orm' {
+    interface IModelClassRecord {
+        'home-user:role': ModelRole;
+        'home-user:roleUser': ModelRoleUser;
+        'home-user:user': ModelUser;
+    }
 }
 /** model: end */
 /** service: begin */
@@ -100,12 +192,28 @@ declare module 'vona-module-a-bean' {
 declare module 'vona-module-home-user' {
     interface ServiceAuthInnerAdapter {
     }
+    interface ServiceAuthInnerAdapter {
+        get $beanFullName(): 'home-user.service.authInnerAdapter';
+        get $onionName(): 'home-user:authInnerAdapter';
+    }
     interface ServicePassportAdapter {
     }
+    interface ServicePassportAdapter {
+        get $beanFullName(): 'home-user.service.passportAdapter';
+        get $onionName(): 'home-user:passportAdapter';
+    }
+    interface ServiceRoleInnerAdapter {
+    }
     interface ServiceRoleInnerAdapter {
+        get $beanFullName(): 'home-user.service.roleInnerAdapter';
+        get $onionName(): 'home-user:roleInnerAdapter';
     }
     interface ServiceUserInnerAdapter {
     }
+    interface ServiceUserInnerAdapter {
+        get $beanFullName(): 'home-user.service.userInnerAdapter';
+        get $onionName(): 'home-user:userInnerAdapter';
+    }
 }
 /** service: end */
 /** service: begin */
@@ -145,7 +253,15 @@ declare module 'vona' {
 declare module 'vona-module-home-user' {
     interface MetaIndex {
     }
+    interface MetaIndex {
+        get $beanFullName(): 'home-user.meta.index';
+        get $onionName(): 'home-user:index';
+    }
+    interface MetaVersion {
+    }
     interface MetaVersion {
+        get $beanFullName(): 'home-user.meta.version';
+        get $onionName(): 'home-user:version';
     }
 }
 /** meta: end */
@@ -159,9 +275,9 @@ import type { IDtoOptionsPassportJwt } from '../dto/passportJwt.ts';
 import 'vona';
 declare module 'vona-module-a-web' {
     interface IDtoRecord {
-        'home-user:auth': Omit<IDtoOptionsAuth, '_fieldsMore_'>;
-        'home-user:passport': Omit<IDtoOptionsPassport, '_fieldsMore_'>;
-        'home-user:passportJwt': Omit<IDtoOptionsPassportJwt, '_fieldsMore_'>;
+        'home-user:auth': IDtoOptionsAuth;
+        'home-user:passport': IDtoOptionsPassport;
+        'home-user:passportJwt': IDtoOptionsPassportJwt;
     }
 }
 declare module 'vona-module-home-user' {
@@ -173,13 +289,13 @@ import type { DtoPassport } from '../dto/passport.ts';
 import type { DtoPassportJwt } from '../dto/passportJwt.ts';
 declare module 'vona-module-home-user' {
     interface IDtoOptionsAuth {
-        fields?: TypeEntityOptionsFields<DtoAuth, IDtoOptionsAuth['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<DtoAuth, IDtoOptionsAuth[TypeSymbolKeyFieldsMore]>;
     }
     interface IDtoOptionsPassport {
-        fields?: TypeEntityOptionsFields<DtoPassport, IDtoOptionsPassport['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<DtoPassport, IDtoOptionsPassport[TypeSymbolKeyFieldsMore]>;
     }
     interface IDtoOptionsPassportJwt {
-        fields?: TypeEntityOptionsFields<DtoPassportJwt, IDtoOptionsPassportJwt['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<DtoPassportJwt, IDtoOptionsPassportJwt[TypeSymbolKeyFieldsMore]>;
     }
 }
 /** dto: end */
@@ -195,6 +311,10 @@ declare module 'vona-module-a-web' {
 declare module 'vona-module-home-user' {
     interface ControllerPassport {
     }
+    interface ControllerPassport {
+        get $beanFullName(): 'home-user.controller.passport';
+        get $onionName(): 'home-user:passport';
+    }
 }
 /** controller: end */
 /** controller: begin */
@@ -216,20 +336,40 @@ declare module 'vona-module-a-web' {
         '/home/user/passport/login': undefined;
         '/home/user/passport/refreshAuthToken': undefined;
         '/home/user/passport/createPassportJwtFromOauthCode': undefined;
+        '/home/user/passport/createTempAuthToken': undefined;
     }
 }
 /** controller: end */
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';
-/** config: end */
+export declare const locales: {
+    'en-us': {
+        Role: string;
+        RoleName: string;
+        User: string;
+        UserName: string;
+        UserAvatar: string;
+        UserLocale: string;
+    };
+    'zh-cn': {
+        Role: string;
+        RoleName: string;
+        User: string;
+        UserName: string;
+        UserAvatar: string;
+        UserLocale: string;
+    };
+};
+/** locale: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
 export declare class ScopeModuleHomeUser extends BeanScopeBase {
 }
 export interface ScopeModuleHomeUser {
     util: BeanScopeUtil;
     config: TypeModuleConfig<typeof config>;
+    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
     entity: IModuleEntity;
     model: IModuleModel;
     service: IModuleService;
@@ -245,5 +385,9 @@ declare module 'vona' {
     interface IBeanScopeConfig {
         'home-user': ReturnType<typeof config>;
     }
+    interface IBeanScopeLocale {
+        'home-user': (typeof locales)[TypeLocaleBase];
+    }
 }
+export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `home-user::${K}`;
 /** scope: end */

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/config/locale/en-us.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    Role: string;
+    RoleName: string;
+    User: string;
+    UserName: string;
+    UserAvatar: string;
+    UserLocale: string;
+};
+export default _default;

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/config/locale/zh-cn.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    Role: string;
+    RoleName: string;
+    User: string;
+    UserName: string;
+    UserAvatar: string;
+    UserLocale: string;
+};
+export default _default;

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/controller/passport.d.ts

@@ -16,6 +16,7 @@ export declare class ControllerPassport extends BeanBase {
     migrate<T extends keyof IAuthProviderRecord>(module: string, providerName: string, clientName?: IAuthenticateOptions<IAuthProviderRecord[T]>['clientName'], redirect?: string): Promise<DtoPassportJwt>;
     refreshAuthToken(refreshToken: string): Promise<DtoJwtToken>;
     createPassportJwtFromOauthCode(code: string): Promise<DtoPassportJwt>;
+    createTempAuthToken(path?: string): Promise<string>;
     private _combineDtoPassportJwt;
     private _combineDtoPassport;
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/dto/auth.d.ts

@@ -1,4 +1,4 @@
-import type { TableIdentity } from 'vona-module-a-database';
+import type { TableIdentity } from 'vona-module-a-orm';
 import type { IAuthBase } from 'vona-module-a-user';
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 export interface IDtoOptionsAuth extends IDecoratorDtoOptions {

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/entity/role.d.ts

@@ -1,5 +1,6 @@
-import type { IDecoratorEntityOptions } from 'vona-module-a-database';
-import { EntityBase } from 'vona-module-a-database';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { EntityBase } from 'vona-module-a-orm';
+import '../.metadata/index.ts';
 export interface IEntityOptionsRole extends IDecoratorEntityOptions {
 }
 export declare class EntityRole extends EntityBase {

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/entity/roleUser.d.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { EntityBase } from 'vona-module-a-orm';
+export interface IEntityOptionsRoleUser extends IDecoratorEntityOptions {
+}
+export declare class EntityRoleUser extends EntityBase {
+    userId: TableIdentity;
+    roleId: TableIdentity;
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/entity/user.d.ts

@@ -1,6 +1,7 @@
 import type { ILocaleInfos } from 'vona';
-import type { IDecoratorEntityOptions } from 'vona-module-a-database';
-import { EntityBase } from 'vona-module-a-database';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { EntityBase } from 'vona-module-a-orm';
+import '../.metadata/index.ts';
 export interface IEntityOptionsUser extends IDecoratorEntityOptions {
 }
 export declare class EntityUser extends EntityBase {

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/entity/userRole.d.ts

@@ -1,5 +1,5 @@
-import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-database';
-import { EntityBase } from 'vona-module-a-database';
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { EntityBase } from 'vona-module-a-orm';
 export interface IEntityOptionsUserRole extends IDecoratorEntityOptions {
 }
 export declare class EntityUserRole extends EntityBase {

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/model/role.d.ts

@@ -1,4 +1,7 @@
-import { BeanModelBase } from 'vona-module-a-database';
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase } from 'vona-module-a-orm';
 import { EntityRole } from '../entity/role.ts';
+export interface IModelOptionsRole extends IDecoratorModelOptions<EntityRole> {
+}
 export declare class ModelRole extends BeanModelBase<EntityRole> {
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/model/roleUser.d.ts

@@ -0,0 +1,7 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase } from 'vona-module-a-orm';
+import { EntityRoleUser } from '../entity/roleUser.ts';
+export interface IModelOptionsRoleUser extends IDecoratorModelOptions<EntityRoleUser> {
+}
+export declare class ModelRoleUser extends BeanModelBase<EntityRoleUser> {
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/model/user.d.ts

@@ -1,4 +1,7 @@
-import { BeanModelBase } from 'vona-module-a-database';
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase } from 'vona-module-a-orm';
 import { EntityUser } from '../entity/user.ts';
+export interface IModelOptionsUser extends IDecoratorModelOptions<EntityUser> {
+}
 export declare class ModelUser extends BeanModelBase<EntityUser> {
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/model/userRole.d.ts

@@ -1,4 +1,7 @@
-import { BeanModelBase } from 'vona-module-a-database';
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase } from 'vona-module-a-orm';
 import { EntityUserRole } from '../entity/userRole.ts';
+export interface IModelOptionsUserRole extends IDecoratorModelOptions {
+}
 export declare class ModelUserRole extends BeanModelBase<EntityUserRole> {
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/service/roleInnerAdapter.d.ts

@@ -5,5 +5,5 @@ import { BeanBase } from 'vona';
 export declare class ServiceRoleInnerAdapter extends BeanBase implements IRoleInnerAdapter {
     findOneByName(name: string): Promise<IRoleBase | undefined>;
     findOne(role: Partial<IRole>): Promise<IRoleBase | undefined>;
-    findAllByUserId(userId: TableIdentity): Promise<IRoleBase[]>;
+    findAllByUserId(userId: TableIdentity): Promise<IRoleBase[] | undefined>;
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/dist/types/passport.d.ts

@@ -1,5 +1,5 @@
-import type { TableIdentity } from 'vona-module-a-database';
 import type { IPayloadDataBase } from 'vona-module-a-jwt';
+import type { TableIdentity } from 'vona-module-a-orm';
 import type { IPassportBase } from 'vona-module-a-user';
 import type { IAuth } from './auth.ts';
 import type { IUser } from './user.ts';