diff --git a/game-server/app/services/playerCeService.ts b/game-server/app/services/playerCeService.ts
index 8a067edec..d947d6c23 100644
--- a/game-server/app/services/playerCeService.ts
+++ b/game-server/app/services/playerCeService.ts
@@ -9,7 +9,7 @@ import { STATUS } from '../consts/statusCode';
 import { resResult, deepCopy } from '../pubUtils/util';
 import Hero from '../db/Hero';
 import { RoleModel } from '../db/Role';
-import { CeAttrData, CeAttr } from '../db/BaseModel';
+import { CeAttrData, CeAttr } from '../db/generalField';
 import { getFashionsById, getJobInfoById, getJobByGradeAndClass, getHeroInfoById, getHeroStar, getHeroWake, getFiendShipLevel, getFriendShipById, getHeroSkillById, getSeidById } from '../pubUtils/gamedata';
 import { getAttrNameByJobStage, getAttrCeRatio, getAtrrNameById, ABI_TYPE_TO_STAGE, ABI_STAGE, SEID_TYPE, HERO_ATTR} from '../consts';
 const HERO_CE_RATIO = 100;
@@ -61,6 +61,7 @@ export async function calPlayerCeAndSave(sid: string, roleId: string, heros: Arr
     for (let hero of heros) {
         let incHeroCe = calPlayerCe(hero, type, args);
         incPlayerCe += incHeroCe;
+
         await hero.save();
         pushHeros.push({
             hid: hero.hid,
@@ -216,7 +217,7 @@ export function calHeroFavourUpIncAttr(hero: any, args: Array<number>) {
         difAdd -= lastFiendShipLevel.add;
     }
     let attrName;
-    for (let connect of hero.conections) {
+    for (let connect of hero.connections) {
         let heroShip = getFriendShipById(connect.shipId, connect.level);  
         for (let attr of heroShip.attributes) {
             attrName = getAtrrNameById(attr.id);
diff --git a/shared/db/ActionPoint.ts b/shared/db/ActionPoint.ts
index 65e05bdf7..06ae33bb3 100644
--- a/shared/db/ActionPoint.ts
+++ b/shared/db/ActionPoint.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 体力系统 
@@ -16,7 +16,7 @@ export default class ActionPoint extends BaseModel {
     ap: number;                     // 当前体力
 
     public static async getAp(roleId: string, lean = true) {
-        let result = await ActionPointModel.findOne({roleId}).select('ap refTime').lean(lean);
+        let result: ActionPointType = await ActionPointModel.findOne({roleId}).select('ap refTime').lean(lean);
         if(!result) {
             result = await ActionPointModel.findOneAndUpdate({roleId}, { ap: 0, refTime: 0 }, {new: true, upsert: true}).lean(lean)
         }
@@ -24,14 +24,16 @@ export default class ActionPoint extends BaseModel {
     }
   
     public static async saveAp(roleId: string, ap: number, refTime: number, lean = true) {
-        let result = await ActionPointModel.findOneAndUpdate({roleId}, { ap, refTime }, {upsert: true, new: true}).lean(lean);
-        return result||{};
+        let result: ActionPointType = await ActionPointModel.findOneAndUpdate({roleId}, { ap, refTime }, {upsert: true, new: true}).lean(lean);
+        return result;
     }
 
-    public static async deleteAccount(roleId: string, lean = true) {
-        let result = await ActionPointModel.deleteMany({roleId}).lean(lean);
-        return result||{};
+    public static async deleteAccount(roleId: string) {
+        let result = await ActionPointModel.deleteMany({roleId});
+        return result;
     }
 }
 
 export const ActionPointModel = getModelForClass(ActionPoint);
+
+export interface ActionPointType extends Pick<DocumentType<ActionPoint>, keyof ActionPoint>{}
\ No newline at end of file
diff --git a/shared/db/Api.ts b/shared/db/Api.ts
index 4c6dfa96b..2175121b2 100644
--- a/shared/db/Api.ts
+++ b/shared/db/Api.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { COUNTER } from './../consts';
 import { CounterModel } from './Counter';
 
@@ -21,21 +21,23 @@ export default class Api extends BaseModel {
   name: string;
 
   public static async getApi(api: string, lean = true) {
-    let result = await ApiModel.findOne({api}).select('apiId api name').lean(lean);
+    let result: ApiType = await ApiModel.findOne({api}).select('apiId api name').lean(lean);
     return result;
   }
 
   public static async getAllApi(lean = true) {
-    const api = await ApiModel.find().sort({apiId: 1}).lean(lean);
+    const api: ApiType[] = await ApiModel.find().sort({apiId: 1}).lean(lean);
     return api;
   }
 
   public static async createApi(api:string, name: string, lean = true) {
     const apiId = await CounterModel.getNewCounter(COUNTER.API);
-    const result = await ApiModel.findOneAndUpdate({apiId}, {$set:{api, name}}, {upsert: true, new: true}).lean(lean);
+    const result: ApiType = await ApiModel.findOneAndUpdate({apiId}, {$set:{api, name}}, {upsert: true, new: true}).lean(lean);
     return result;
   }
   
 }
 
 export const ApiModel = getModelForClass(Api);
+
+export interface ApiType extends Pick<DocumentType<Api>, keyof Api>{}
diff --git a/shared/db/BaseModel.ts b/shared/db/BaseModel.ts
index 779100c34..23807ef1d 100644
--- a/shared/db/BaseModel.ts
+++ b/shared/db/BaseModel.ts
@@ -23,45 +23,3 @@ export default class BaseModel extends TimeStamps {
   @prop()
   updatedAt: Date
 }
-
-export class CeAttrData {
-    @prop({ required: true })
-    base?: number = 0;
-    @prop({ required: true })
-    ratioUp: number = 0;
-    @prop({ required: true })
-    fixUp: number = 0;
-}
-
-export class CeAttr {
-  @prop({ required: false })
-  hp?: CeAttrData;
-  @prop({ required: false })
-  atk?: CeAttrData;
-  @prop({ required: false })
-  matk?: CeAttrData;
-  @prop({ required: false })
-  def?: CeAttrData;
-  @prop({ required: false })
-  mdef?: CeAttrData;
-  @prop({ required: false })
-  agi?: CeAttrData;
-  @prop({ required: false })
-  luk?: CeAttrData;
-  @prop({ required: false })
-  hit?: CeAttrData;
-  @prop({ required: false })
-  cri?: CeAttrData;
-  @prop({ required: false })
-  flee?: CeAttrData;
-  @prop({ required: false })
-  antCri?: CeAttrData;
-  @prop({ required: false })
-  damageIncrease?: CeAttrData;
-  @prop({ required: false })
-  damageDecrease?: CeAttrData;
-  @prop({ required: false })
-  defIngnore?: CeAttrData;
-  @prop({ required: false })
-  bloodSuck?: CeAttrData;
-}
\ No newline at end of file
diff --git a/shared/db/BattleBlueprtDrop.ts b/shared/db/BattleBlueprtDrop.ts
index 0ecac679b..e01c029ba 100644
--- a/shared/db/BattleBlueprtDrop.ts
+++ b/shared/db/BattleBlueprtDrop.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 藏宝图掉落记录
@@ -22,21 +22,23 @@ export default class BattleBlueprtDrop extends BaseModel {
   costAp: number;						// 当天消耗的ap
 
   public static async findByTime(roleId: string, refTime: Date, lean = true) {
-    const result = await BattleBlueprtDropModel.findOneAndUpdate({ roleId,  refTime }, {}, {new: true, upsert: true}).lean(lean);
+    const result: BattleBlueprtDropType = await BattleBlueprtDropModel.findOneAndUpdate({ roleId,  refTime }, {}, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
   public static async updateByTime(roleId: string, refTime: Date, params: {getNum: number, curCostAp: number, getSum: number, costAp: number}, lean = true) {
-    const result = await BattleBlueprtDropModel.findOneAndUpdate({roleId, refTime}, {$set: params}).lean(lean);
+    const result: BattleBlueprtDropType = await BattleBlueprtDropModel.findOneAndUpdate({roleId, refTime}, {$set: params}).lean(lean);
     return result;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await BattleBlueprtDropModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await BattleBlueprtDropModel.deleteMany({roleId});
+    return result;
   }
 
   
 }
 
 export const BattleBlueprtDropModel = getModelForClass(BattleBlueprtDrop);
+
+export interface BattleBlueprtDropType extends Pick<DocumentType<BattleBlueprtDrop>, keyof BattleBlueprtDrop>{}
\ No newline at end of file
diff --git a/shared/db/BattleDrop.ts b/shared/db/BattleDrop.ts
index 0629fcd57..ec2f6f3c6 100644
--- a/shared/db/BattleDrop.ts
+++ b/shared/db/BattleDrop.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 战斗记录接口
@@ -25,19 +25,21 @@ export default class BattleDrop extends BaseModel {
 
 
   public static async findByGid(roleId: string, battleId: number, gid: number, lean = true) {
-    const result = await BattleDropModel.findOneAndUpdate({ roleId,  battleId, gid}, {}, {new: true, upsert: true}).lean(lean);
+    const result: BattleDropType = await BattleDropModel.findOneAndUpdate({ roleId,  battleId, gid}, {}, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
   public static async updateByGid(roleId: string, battleId: number, gid: number, params: {getNum: number, allNum: number, getSum: number, allSum: number}, lean = true) {
-    const result = await BattleDropModel.findOneAndUpdate({roleId, battleId, gid}, {$set: params}).lean(lean);
+    const result: BattleDropType = await BattleDropModel.findOneAndUpdate({roleId, battleId, gid}, {$set: params}).lean(lean);
     return result;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await BattleDropModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await BattleDropModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const BattleDropModel = getModelForClass(BattleDrop);
+
+export interface BattleDropType extends Pick<DocumentType<BattleDrop>, keyof BattleDrop>{}
\ No newline at end of file
diff --git a/shared/db/BattleRecord.ts b/shared/db/BattleRecord.ts
index a6fe6ca28..60c680837 100644
--- a/shared/db/BattleRecord.ts
+++ b/shared/db/BattleRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 战斗记录接口
@@ -32,29 +32,31 @@ export default class BattleRecord extends BaseModel {
   };
 
   public static async getBattleRecordByCode(battleCode: string, lean = true) {
-    const result = await BattleRecordModel.findOne({ battleCode }).lean(lean);
+    const result: BattleRecordType = await BattleRecordModel.findOne({ battleCode }).lean(lean);
     return result;
   }
 
   public static async getBattleRecordByIdAndStatus(roleId: string, battleId: number, status: number, lean = true) {
-    const result = await BattleRecordModel.findOne({ roleId, battleId, status }).lean(lean);
+    const result: BattleRecordType = await BattleRecordModel.findOne({ roleId, battleId, status }).lean(lean);
     return result;
   }
 
   public static async getBattleRecordByIdAndStar(roleId: string, battleId: number, star: number, lean = true) {
-    const result = await BattleRecordModel.findOne({ roleId, battleId, star: {$lte: star} }).lean(lean);
+    const result: BattleRecordType = await BattleRecordModel.findOne({ roleId, battleId, star: {$lte: star} }).lean(lean);
     return result;
   }
 
   public static async updateBattleRecordByCode( battleCode: string, params: object, lean = true) {
-    const result = await BattleRecordModel.findOneAndUpdate({ battleCode }, params, {new: true, upsert: true}).lean(lean);
+    const result: BattleRecordType = await BattleRecordModel.findOneAndUpdate({ battleCode }, params, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await BattleRecordModel.deleteMany({roleId}).lean(lean);
+  public static async deleteAccount(roleId: string) {
+    let result = await BattleRecordModel.deleteMany({roleId});
     return result||{};
   }
 }
 
 export const BattleRecordModel = getModelForClass(BattleRecord);
+
+export interface BattleRecordType extends Pick<DocumentType<BattleRecord>, keyof BattleRecord>{}
\ No newline at end of file
diff --git a/shared/db/BattleSweepRecord.ts b/shared/db/BattleSweepRecord.ts
index 42ff8d79c..137c527c2 100644
--- a/shared/db/BattleSweepRecord.ts
+++ b/shared/db/BattleSweepRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 战斗记录接口
@@ -23,14 +23,16 @@ export default class BattleSweepRecord extends BaseModel {
   count: number;						// 扫荡次数
 
   public static async saveBattleSweepRecordById(roleId: string, battleId: number, params: any, lean = true) {
-    const result = await BattleSweepRecordModel.findOneAndUpdate({ roleId, battleId }, params, {new: true, upsert: true}).lean(lean);
+    const result: BattleSweepRecordType = await BattleSweepRecordModel.findOneAndUpdate({ roleId, battleId }, params, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await BattleSweepRecordModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await BattleSweepRecordModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const BattleSweepRecordModel = getModelForClass(BattleSweepRecord);
+
+export interface BattleSweepRecordType extends Pick<DocumentType<BattleSweepRecord>, keyof BattleSweepRecord>{}
diff --git a/shared/db/ComBattleTeam.ts b/shared/db/ComBattleTeam.ts
index d6d5766cf..44888bba8 100644
--- a/shared/db/ComBattleTeam.ts
+++ b/shared/db/ComBattleTeam.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 export class RoleStatus {
     @prop({ required: true })
@@ -126,48 +126,48 @@ export default class ComBattleTeam extends BaseModel {
     bossHpArr: Array<BossHp>;
 
     public static async createTeam(teamData: {teamCode: string, roleIds: Array<string>, pub: boolean, blueprtId: number, quality: number, status: number, roleStatus: Array<RoleStatus>, capId: string, ceLimit: number}, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleIds.length}}, {upsert: true, new: true}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleIds.length}}, {upsert: true, new: true}).lean(lean);
         return team;
     }
 
     public static async addRole(teamCode: string, roleStatus: RoleStatus, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$push: {roleIds: roleStatus.roleId, roleStatus}, $inc: {roleCnt: 1}}, {new: true}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$push: {roleIds: roleStatus.roleId, roleStatus}, $inc: {roleCnt: 1}}, {new: true}).lean(lean);
         return team;
     }
 
     public static async removeRole(teamCode: string, roleIdToRm: string, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$pull: {roleIds: roleIdToRm, roleStatus: {roleId: roleIdToRm}}, $inc: {roleCnt: -1}}, {new: true}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$pull: {roleIds: roleIdToRm, roleStatus: {roleId: roleIdToRm}}, $inc: {roleCnt: -1}}, {new: true}).lean(lean);
         return team;
     }
 
     public static async removeTeam(teamCode: string, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndDelete({ teamCode }).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndDelete({ teamCode }).lean(lean);
         return team;
     }
 
     public static async updateHeroes(teamCode: string, roleId: string, heroes: Array<number>, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes}}, {new: true}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes}}, {new: true}).lean(lean);
         return team;
     }
 
     public static async setupBattleInfo(teamCode: string, roleId: string, heroes: Array<number>, battleCode: string, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes, 'roleStatus.$.battleCode': battleCode}}, {new: true}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes, 'roleStatus.$.battleCode': battleCode}}, {new: true}).lean(lean);
         return team;
     }
 
     public static async updateRewardSt(teamCode: string, roleId: string, gotReward: boolean, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.gotReward': gotReward}}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.gotReward': gotReward}}).lean(lean);
         return team;
     }
 
     public static async syncTeamData(teamData: {teamCode: string, status: number, roleStatus: Array<RoleStatus>, bossHpArr: Array<BossHp>}, lean = true) {
         console.log('syncTeamData bossHpArr: ', teamData.bossHpArr);
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleStatus.length}}, {new: true}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleStatus.length}}, {new: true}).lean(lean);
         return team;
     }
 
     public static async updateStatus(teamCode: string, status: number, lean = true) {
-        const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamCode }, {status}, {new: true}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamCode }, {status}, {new: true}).lean(lean);
         return team;
     }
 
@@ -199,22 +199,22 @@ export default class ComBattleTeam extends BaseModel {
     }
 
     public static async getTeamByCapAndStatus(roleId: string, status: number, lean = true) {
-        const teams = await ComBattleTeamModel.find({capId: roleId, status}).lean(lean);
+        const teams: ComBattleTeamType[] = await ComBattleTeamModel.find({capId: roleId, status}).lean(lean);
         return teams;
     }
 
     public static async getTeamByBlueprt(blueprtIds: Array<number>, status: number, pub = true, limit = 50, lean = true) {
-        const teams = await ComBattleTeamModel.find({blueprtId: {$in: blueprtIds}, status, pub}).limit(limit).lean(lean);
+        const teams: ComBattleTeamType[] = await ComBattleTeamModel.find({blueprtId: {$in: blueprtIds}, status, pub}).limit(limit).lean(lean);
         return teams;
     }
 
     public static async getOneTeamByQualityAndSt(qualityArr: Array<number>, status: number, ce = 0, pub = true, cntLmt = 2, lean = true) {
-        const team = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}}).lean(lean);
         return team;
     }
 
     public static async getOtherTeamByQualityAndSt(roleId: string, qualityArr: Array<number>, status: number, ce = 0, pub = true, cntLmt = 2, lean = true) {
-        const team = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}, roleIds: {$nin: [roleId]}}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}, roleIds: {$nin: [roleId]}}).lean(lean);
         return team;
     }
 
@@ -229,7 +229,7 @@ export default class ComBattleTeam extends BaseModel {
         if (isAssist) {
             query = Object.assign(query, {capId: {$ne: roleId}});
         }
-        const teams = await ComBattleTeamModel.find(query).limit(limitCnt).lean(lean);
+        const teams: ComBattleTeamType[] = await ComBattleTeamModel.find(query).limit(limitCnt).lean(lean);
         return teams;
     }
 
@@ -244,19 +244,21 @@ export default class ComBattleTeam extends BaseModel {
         if (isAssist) {
             query = Object.assign(query, {capId: {$ne: roleId}});
         }
-        const teams = await ComBattleTeamModel.find(query).lean(lean);
+        const teams: ComBattleTeamType[] = await ComBattleTeamModel.find(query).lean(lean);
         return teams;
     }
 
     public static async getTeamByRoleAndBattleCode(roleId: string, battleCode: string, lean = true) {
-        const team = await ComBattleTeamModel.findOne({roleIds: roleId, 'roleStatus.battleCode': battleCode}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOne({roleIds: roleId, 'roleStatus.battleCode': battleCode}).lean(lean);
         return team;
     }
 
     public static async getTeamByCode(teamCode: string, lean = true) {
-        const team = await ComBattleTeamModel.findOne({teamCode}).lean(lean);
+        const team: ComBattleTeamType = await ComBattleTeamModel.findOne({teamCode}).lean(lean);
         return team;
     }
 }
 
-export const ComBattleTeamModel = getModelForClass(ComBattleTeam);
\ No newline at end of file
+export const ComBattleTeamModel = getModelForClass(ComBattleTeam);
+
+export interface ComBattleTeamType extends Pick<DocumentType<ComBattleTeam>, keyof ComBattleTeam>{};
\ No newline at end of file
diff --git a/shared/db/Counter.ts b/shared/db/Counter.ts
index 7dfe8f274..6f4f7fc64 100644
--- a/shared/db/Counter.ts
+++ b/shared/db/Counter.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 自增 ID
@@ -15,7 +15,7 @@ export default class Counter extends BaseModel {
 
   public static async getNewCounter(param:{name: string, def: number}, lean = true) {
     let {name, def:defaultVal} = param;
-    let counter = await CounterModel.findOneAndUpdate({ name }, { $inc: { seq: 1 } }, { new: true, upsert: true }).lean(lean);
+    let counter: CounterType = await CounterModel.findOneAndUpdate({ name }, { $inc: { seq: 1 } }, { new: true, upsert: true }).lean(lean);
     if(!counter || (counter&&counter.seq == 1) && defaultVal != 1) {
       counter = await CounterModel.findOneAndUpdate({ name }, { $set: { seq: defaultVal } }, { new: true, upsert: true }).lean(lean);
     }
@@ -24,4 +24,6 @@ export default class Counter extends BaseModel {
 
 }
 
-export const CounterModel = getModelForClass(Counter);
\ No newline at end of file
+export const CounterModel = getModelForClass(Counter);
+
+export interface CounterType extends Pick<DocumentType<Counter>, keyof Counter>{};
\ No newline at end of file
diff --git a/shared/db/DailyRecord.ts b/shared/db/DailyRecord.ts
index e5a953313..8269d1bf7 100644
--- a/shared/db/DailyRecord.ts
+++ b/shared/db/DailyRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { DAILY_CONST } from './../consts';
 import { setLocalHours } from './../pubUtils/util';
 
@@ -22,12 +22,12 @@ export default class DailyRecord extends BaseModel {
   refTime: number;				// 刷新时间
 
   public static async getDailyRecordById(roleId: string, type: number, lean = true) {
-    const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {}, {new: true, upsert: true}).lean(lean);
+    const result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {}, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
   public static async refreshRecord(roleId: string, type: number, lean = true) {
-    const dailyRecord = await DailyRecordModel.findOne({ roleId, type }).lean(lean);
+    const dailyRecord: DailyRecordType = await DailyRecordModel.findOne({ roleId, type }).lean(lean);
     let {count = 0, refTime = 0, buyCount = 0} = dailyRecord||{};
     let now = new Date();
     let today = setLocalHours(DAILY_CONST.REFRESH_TIME, now);
@@ -35,24 +35,26 @@ export default class DailyRecord extends BaseModel {
     if(today > refTime) {
         refTime = today; count = 0; buyCount = 0;
     }
-    let result = await DailyRecordModel.findOneAndUpdate({roleId, type}, {$set: {refTime, count, buyCount}}, {new: true, upsert: true});
+    let result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({roleId, type}, {$set: {refTime, count, buyCount}}, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
   public static async increseDailyCount(roleId: string, type: number, count: number, lean = true) {
-    const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { count } }, {new: true, upsert: true}).lean(lean);
+    const result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { count } }, {new: true, upsert: true}).lean(lean);
     return result;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await DailyRecordModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await DailyRecordModel.deleteMany({roleId});
+    return result;
   }
 
   public static async increseBuyCount(roleId: string, type: number, count: number, lean = true) {
-    const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { buyCount:count } }, {new: true, upsert: true}).lean(lean);
+    const result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { buyCount:count } }, {new: true, upsert: true}).lean(lean);
     return result;
   }
 }
 
 export const DailyRecordModel = getModelForClass(DailyRecord);
+
+export interface DailyRecordType extends Pick<DocumentType<DailyRecord>, keyof DailyRecord>{};
diff --git a/shared/db/Equip.ts b/shared/db/Equip.ts
index 53d8039ee..79bc62f43 100644
--- a/shared/db/Equip.ts
+++ b/shared/db/Equip.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class RandSe {
   @prop({ required: true })
@@ -50,26 +50,28 @@ export default class Equip extends BaseModel {
   holes: Holes[];
 
   public static async findbyRole(roleId: string, lean = true) {
-    const equips = await EquipModel.find({ roleId }).lean(lean);
+    const equips: EquipType[] = await EquipModel.find({ roleId }).lean(lean);
     return equips;
   }
   
   public static async createEquip(equipInfo: {roleId: string, roleName: string, id: number, seqId: number, type: number, name: string, lv?: number}, lean = true) {
     const doc = new EquipModel();
     const update = Object.assign(doc.toJSON(), equipInfo);
-    const equip = await EquipModel.findOneAndUpdate({ seqId: equipInfo.seqId }, update, {upsert: true, new: true}).lean(lean);
+    const equip: EquipType = await EquipModel.findOneAndUpdate({ seqId: equipInfo.seqId }, update, {upsert: true, new: true}).lean(lean);
     return equip;
   }
 
   public static async putOn(hid: number, equipId: string, lean = true) {
-    const equip = await EquipModel.findOneAndUpdate({ _id: equipId }, {hid}, {new: true}).lean(lean);
+    const equip: EquipType = await EquipModel.findOneAndUpdate({ _id: equipId }, {hid}, {new: true}).lean(lean);
     return equip;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await EquipModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await EquipModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const EquipModel = getModelForClass(Equip);
+
+export interface EquipType extends Pick<DocumentType<Equip>, keyof Equip>{};
\ No newline at end of file
diff --git a/shared/db/EventRecord.ts b/shared/db/EventRecord.ts
index 817376c51..e2f94cacb 100644
--- a/shared/db/EventRecord.ts
+++ b/shared/db/EventRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class Question {
   @prop({ required: true })
@@ -47,23 +47,23 @@ export default class EventRecord extends BaseModel {
 
     
     public static async getEventRecordByTime(roleId: string, refTime: number, lean=true ) {
-      let data = await EventRecordModel.find({roleId, refTime}).select('eventCode eventId type quality status battleId point question').lean(lean);
+      let data: EventRecordType[] = await EventRecordModel.find({roleId, refTime}).select('eventCode eventId type quality status battleId point question').lean(lean);
       return data;
     }
 
     public static async getEventRecordByCode(roleId: string, eventCode: string, lean=true ) {
-      let data = await EventRecordModel.findOne({roleId, eventCode}).lean(lean);
+      let data: EventRecordType = await EventRecordModel.findOne({roleId, eventCode}).lean(lean);
       return data;
     }
     public static async getHostoryEventRecord(roleId: string, lean=true) {
-        let latest = await EventRecordModel.findOne({roleId}).sort({turn: -1}).lean();
+        let latest: EventRecordType = await EventRecordModel.findOne({roleId}).sort({turn: -1}).lean();
         let {turn = 0} = latest||{};
-        let result = await EventRecordModel.find({roleId, turn}).lean(lean);
+        let result: EventRecordType[] = await EventRecordModel.find({roleId, turn}).lean(lean);
         return {history: result, turn};
     }
 
     public static async saveEventAnswer(eventCode: string, questionId: number, status: number , lean=true ) {
-      let data = await EventRecordModel.findOneAndUpdate(
+      let data: EventRecordType = await EventRecordModel.findOneAndUpdate(
         {eventCode, 'question.id': questionId}, { $set: {'question.$.status': status} }, {upsert: true, new: true}).lean(lean);
       return data;
     }
@@ -71,29 +71,31 @@ export default class EventRecord extends BaseModel {
     public static async saveEventRecord(eventCode: string, params: {roleId: string, refTime: number, eventId: number, roleName:string, turn?: number, type: number, quality: number, battleId?: number, status: number, point: number, question: Array<any> } , lean=true ) {
       let doc = new EventRecordModel();
       let update = Object.assign(doc.toJSON(), params, {eventCode});
-      let data = await EventRecordModel.findOneAndUpdate({eventCode}, { $set: update }, {upsert: true, new: true}).select('eventCode eventId type quality status battleId point question').lean(lean);
+      let data: EventRecordType = await EventRecordModel.findOneAndUpdate({eventCode}, { $set: update }, {upsert: true, new: true}).select('eventCode eventId type quality status battleId point question').lean(lean);
       return data;
     }
 
     public static async setBattleCode(roleId: string, battleId: number, refTime: number, battleCode: string , lean=true ) {
-      let result = await EventRecordModel.findOneAndUpdate({roleId, battleId, refTime}, {$set:{ battleCode }}).sort({turn: 1}).lean(lean);
+      let result: EventRecordType = await EventRecordModel.findOneAndUpdate({roleId, battleId, refTime}, {$set:{ battleCode }}).sort({turn: 1}).lean(lean);
       return result;
     }
 
     public static async setBattleStatus(roleId: string, battleId: number, battleCode: string, status: number , lean=true ) {
-      let result = await EventRecordModel.findOneAndUpdate({roleId, battleId, battleCode}, {$set:{ status }}).lean(lean);
+      let result: EventRecordType = await EventRecordModel.findOneAndUpdate({roleId, battleId, battleCode}, {$set:{ status }}).lean(lean);
       return result;
     }
 
     public static async setStatusByCode(roleId: string, eventCode: string, status: number , lean=true ) {
-      let result = await EventRecordModel.findOneAndUpdate({ roleId, eventCode }, {$set:{ status }}, {new: true, upsert: true}).lean(lean);
+      let result: EventRecordType = await EventRecordModel.findOneAndUpdate({ roleId, eventCode }, {$set:{ status }}, {new: true, upsert: true}).lean(lean);
       return result;
     }
 
-    public static async deleteAccount(roleId: string, lean = true) {
-      let result = await EventRecordModel.deleteMany({roleId}).lean(lean);
-      return result||{};
+    public static async deleteAccount(roleId: string) {
+      let result = await EventRecordModel.deleteMany({roleId});
+      return result;
     }
 }
 
 export const EventRecordModel = getModelForClass(EventRecord);
+
+export interface EventRecordType extends Pick<DocumentType<EventRecord>, keyof EventRecord>{};
\ No newline at end of file
diff --git a/shared/db/ExpeditionPoint.ts b/shared/db/ExpeditionPoint.ts
index 8381949e0..520f1382a 100644
--- a/shared/db/ExpeditionPoint.ts
+++ b/shared/db/ExpeditionPoint.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 远征记录
@@ -18,12 +18,12 @@ export default class ExpeditionPoint extends BaseModel {
     rewards: Array<{point: number, reward: string, received:boolean, recTime: Date}>;                     // 领取记录
 
     public static async getExpeditionPoint(roleId: string, lean = true) {
-        const result = await ExpeditionPointModel.findOne({ roleId, completed: false }).lean(lean);
+        const result: ExpeditionPointType = await ExpeditionPointModel.findOne({ roleId, completed: false }).lean(lean);
         return result;
     }
 
     public static async updatePointStatus(roleId: string, point: number, reward: string, lean = true) {
-      const result = await ExpeditionPointModel.findOneAndUpdate(
+      const result: ExpeditionPointType = await ExpeditionPointModel.findOneAndUpdate(
         { roleId, completed: false },
         { $set: { pointCost: point }, $push: {rewards:{point, reward, received: true, recTime: new Date()}}},
         { new: true, upsert: true }
@@ -32,17 +32,19 @@ export default class ExpeditionPoint extends BaseModel {
     }
 
     public static async completeStatus(roleId: string, lean = true) {
-      const result = await ExpeditionPointModel.findOneAndUpdate(
+      const result: ExpeditionPointType = await ExpeditionPointModel.findOneAndUpdate(
         { roleId, completed: false },
         { $set: {completed: true } }
       ).lean(lean);
       return result;
     }
 
-    public static async deleteAccount(roleId: string, lean = true) {
-      let result = await ExpeditionPointModel.deleteMany({roleId}).lean(lean);
-      return result||{};
+    public static async deleteAccount(roleId: string) {
+      let result = await ExpeditionPointModel.deleteMany({roleId});
+      return result;
     }
 }
 
 export const ExpeditionPointModel = getModelForClass(ExpeditionPoint);
+
+export interface ExpeditionPointType extends Pick<DocumentType<ExpeditionPoint>, keyof ExpeditionPoint>{};
\ No newline at end of file
diff --git a/shared/db/ExpeditionRecord.ts b/shared/db/ExpeditionRecord.ts
index cf7b16b2d..0da43505f 100644
--- a/shared/db/ExpeditionRecord.ts
+++ b/shared/db/ExpeditionRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { genCode } from '../pubUtils/util';
 
 class Heroes {
@@ -33,24 +33,24 @@ export default class ExpeditionRecord extends BaseModel {
     
 
     public static async getCurRecord(roleId: string, lean = true) {
-        const result = await ExpeditionRecordModel.findOne({ roleId, status: 1 }).lean(lean);
+        const result: ExpeditionRecordType = await ExpeditionRecordModel.findOne({ roleId, status: 1 }).lean(lean);
         return result;
     }
 
     public static async createRecord(params: { roleId: string, roleName: string, heroes: Array<{seqId: number, hp: number, ap: number}>, myCe: number }, lean = true) {
         const code = genCode(8);
         
-        const result = await ExpeditionRecordModel.findOneAndUpdate({ expeditionCode: code }, {...params, status: 1}, { new: true, upsert: true }).lean(lean);
+        const result: ExpeditionRecordType = await ExpeditionRecordModel.findOneAndUpdate({ expeditionCode: code }, {...params, status: 1}, { new: true, upsert: true }).lean(lean);
         return result;
     }
 
     public static async hideRecord(roleId: string, lean = true) {
-        const result = await ExpeditionRecordModel.findOneAndUpdate({ roleId, status: 1 }, { status: 0 }, { new: true }).lean(lean);
+        const result: ExpeditionRecordType = await ExpeditionRecordModel.findOneAndUpdate({ roleId, status: 1 }, { status: 0 }, { new: true }).lean(lean);
         return result;
     }
 
     public static async getExpeditionRecordByCode(expeditionCode: string, lean=true) {
-        const result = await ExpeditionRecordModel.findOne({expeditionCode}).lean(lean);
+        const result: ExpeditionRecordType = await ExpeditionRecordModel.findOne({expeditionCode}).lean(lean);
         return result 
     }
 
@@ -72,7 +72,7 @@ export default class ExpeditionRecord extends BaseModel {
                 {$set: {'heroes.$.seqId': seqId, 'heroes.$.hp': hp, 'heroes.$.ap': ap}}
             )
         }
-        const result = await ExpeditionRecordModel.findOneAndUpdate(
+        const result: ExpeditionRecordType = await ExpeditionRecordModel.findOneAndUpdate(
             { expeditionCode },
             { $push: {heroes: {$each: pushArr} } }
         ).lean(lean)
@@ -80,10 +80,12 @@ export default class ExpeditionRecord extends BaseModel {
         return result;
     }
 
-    public static async deleteAccount(roleId: string, lean = true) {
-        let result = await ExpeditionRecordModel.deleteMany({roleId}).lean(lean);
-        return result||{};
+    public static async deleteAccount(roleId: string) {
+        let result = await ExpeditionRecordModel.deleteMany({roleId});
+        return result;
       }
 }
 
 export const ExpeditionRecordModel = getModelForClass(ExpeditionRecord);
+
+export interface ExpeditionRecordType extends Pick<DocumentType<ExpeditionRecord>, keyof ExpeditionRecord>{};
\ No newline at end of file
diff --git a/shared/db/ExpeditionWarRecord.ts b/shared/db/ExpeditionWarRecord.ts
index 95e869ad8..42bc4fa01 100644
--- a/shared/db/ExpeditionWarRecord.ts
+++ b/shared/db/ExpeditionWarRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { EXPEDITION_WAR_RECORD_STATUS } from '../consts';
 
 class Enemies {
@@ -79,35 +79,35 @@ export default class ExpeditionWarRecord extends BaseModel {
     ce: number;                // 敌军战力
 
     public static async getRecordByCode(expeditionCode: string, lean = true) {
-        const result = await ExpeditionWarRecordModel.find({ expeditionCode, battleStatus: {$gte: EXPEDITION_WAR_RECORD_STATUS.WAITING} }).select('expeditionId battleId battleCode battleStatus ce').sort({expeditionId: 1}).lean(lean);
+        const result: ExpeditionWarRecordType[] = await ExpeditionWarRecordModel.find({ expeditionCode, battleStatus: {$gte: EXPEDITION_WAR_RECORD_STATUS.WAITING} }).select('expeditionId battleId battleCode battleStatus ce').sort({expeditionId: 1}).lean(lean);
         return result;
     }
 
     public static async getRecordByCodeAndId(expeditionCode: string, expeditionId: number, lean = true) {
-        const result = await ExpeditionWarRecordModel.findOne({ expeditionCode, expeditionId }).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
+        const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOne({ expeditionCode, expeditionId }).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
         return result;
     }
     
     public static async saveRecord(expeditionCode: string, expeditionId: number, params: {roleId: string, battleId: number, enemyFrom: number, enemyId: string, enemies: Array<any>, battleStatus: number}, lean = true) {
         const doc = new ExpeditionWarRecordModel();
         const update = Object.assign(doc.toJSON(), params, {expeditionCode, expeditionId});
-        const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, update, {new: true, upsert: true}).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
+        const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, update, {new: true, upsert: true}).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
         return result;
     }
     
     public static async updateStatus(expeditionCode: string, expeditionId: number, battleStatus: number, lean = true) {
-        const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus}, {new: true}).lean(lean);
+        const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus}, {new: true}).lean(lean);
         return result;
     }
 
     public static async updateBattleCode(expeditionCode: string, expeditionId: number, battleStatus: number, battleCode: string, lean = true) {
-        const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus, battleCode}, {new: true}).lean(lean);
+        const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus, battleCode}, {new: true}).lean(lean);
         return result;
     }
 
     public static async updateEnemiesStatus(expeditionCode: string, expeditionId: number, battleStatus: number, enemies: Array<{dataId: number, hp: number, ap: number}>, lean = true) {
 
-        const result = ExpeditionWarRecordModel.findOneAndUpdate(
+        const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate(
             {expeditionCode, expeditionId},
             {$set: {battleStatus}, enemiesCurHpAp: enemies},
             {new: true}
@@ -115,10 +115,12 @@ export default class ExpeditionWarRecord extends BaseModel {
         return result;
     }
 
-    public static async deleteAccount(roleId: string, lean = true) {
-        let result = await ExpeditionWarRecordModel.deleteMany({roleId}).lean(lean);
-        return result||{};
+    public static async deleteAccount(roleId: string) {
+        let result = await ExpeditionWarRecordModel.deleteMany({roleId});
+        return result;
       }
 }
 
 export const ExpeditionWarRecordModel = getModelForClass(ExpeditionWarRecord);
+
+export interface ExpeditionWarRecordType extends Pick<DocumentType<ExpeditionWarRecord>, keyof ExpeditionWarRecord>{};
diff --git a/shared/db/FriendPoint.ts b/shared/db/FriendPoint.ts
index d11a4f07f..5bef855da 100644
--- a/shared/db/FriendPoint.ts
+++ b/shared/db/FriendPoint.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * 情谊点记录
@@ -29,7 +29,7 @@ export default class FriendPoint extends BaseModel {
     public static async updatePointToday(roleId: string, roleName: string, cntInc: number, maxPerDay: number, lean = true) {
         const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
         // 当 oldCnt + cntInc > maxPerDay 时需计算实际可以获得的点数：cntInc - (newCnt - maxPerDay)
-        const rec = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, cnt: {$lt: maxPerDay}}, {$inc: {cnt: cntInc}}, {upsert: true, new: true}).lean(lean);
+        const rec: FriendPointType = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, cnt: {$lt: maxPerDay}}, {$inc: {cnt: cntInc}}, {upsert: true, new: true}).lean(lean);
         return rec;
     }
 
@@ -44,9 +44,11 @@ export default class FriendPoint extends BaseModel {
      */
     public static async getFrdPointRecToday(roleId: string, type: number, lean = true) {
         const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
-        const rec = await FriendPointModel.findOne({roleId, createdAt: {$gte: curTime}, type}).lean(lean);
+        const rec: FriendPointType = await FriendPointModel.findOne({roleId, createdAt: {$gte: curTime}, type}).lean(lean);
         return rec;
     }
 }
 
 export const FriendPointModel = getModelForClass(FriendPoint);
+
+export interface FriendPointType extends Pick<DocumentType<FriendPoint>, keyof FriendPoint>{};
\ No newline at end of file
diff --git a/shared/db/GMGroup.ts b/shared/db/GMGroup.ts
index b68f029ed..1b619745b 100644
--- a/shared/db/GMGroup.ts
+++ b/shared/db/GMGroup.ts
@@ -1,7 +1,7 @@
 import { COUNTER } from './../consts';
 import { CounterModel } from './Counter';
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * GM用户组接口
@@ -28,32 +28,32 @@ export default class GMGroup extends BaseModel {
    
   public static async createGroup(group: string, name: string, desc: string, lean = true) {
     const id = await CounterModel.getNewCounter(COUNTER.GM_GROUP);
-    const result = await GMGroupModel.findOneAndUpdate({id}, {group, desc, name, apis: []}, {upsert: true, new: true}).select('uid username name').lean(lean);
+    const result: GMGroupType = await GMGroupModel.findOneAndUpdate({id}, {group, desc, name, apis: []}, {upsert: true, new: true}).select('uid username name').lean(lean);
     return result;
   }
 
   public static async editGroup(groupId: number, group: string, name: string, desc: string, lean = true) {
-    const result = await GMGroupModel.findOneAndUpdate({ id: groupId }, {$set: {group, desc, name}}).select('uid username name').lean(lean);
+    const result: GMGroupType = await GMGroupModel.findOneAndUpdate({ id: groupId }, {$set: {group, desc, name}}).select('uid username name').lean(lean);
     return result;
   }
 
   public static async getAllGroup(lean = true) {
-    const list = await GMGroupModel.find().lean(lean);
+    const list: GMGroupType[] = await GMGroupModel.find().lean(lean);
     return list;
   }
 
   public static async getGroup(group: string, lean = true) {
-    const result = await GMGroupModel.findOne({ group }).lean(lean);
+    const result: GMGroupType = await GMGroupModel.findOne({ group }).lean(lean);
     return result;
   }
   
   public static async getGroupById(id: number, lean = true) {
-    const result = await GMGroupModel.findOne({ id }).lean(lean);
+    const result: GMGroupType = await GMGroupModel.findOne({ id }).lean(lean);
     return result;
   }
 
   public static async saveApiToGroup(id: number, apis: Array<number>, lean = true) {
-    let group = await GMGroupModel.getGroupById(id);
+    let group: GMGroupType = await GMGroupModel.getGroupById(id);
     if(group) {
       let originApi = group.apis||[];
       let addArr = new Array(), removeArr = new Array();
@@ -66,7 +66,7 @@ export default class GMGroup extends BaseModel {
         if(apis.indexOf(api) == -1) removeArr.push(api);
       }
       await GMGroupModel.findOneAndUpdate({ id }, { $push: {apis: {$each: addArr}} }).lean(lean);
-      const result = await GMGroupModel.findOneAndUpdate({ id }, { $pull: {apis: {$in: removeArr}} }).lean(lean);
+      const result: GMGroupType = await GMGroupModel.findOneAndUpdate({ id }, { $pull: {apis: {$in: removeArr}} }).lean(lean);
       return result;
     }
   }
@@ -75,3 +75,5 @@ export default class GMGroup extends BaseModel {
 }
 
 export const GMGroupModel = getModelForClass(GMGroup);
+
+export interface GMGroupType extends Pick<DocumentType<GMGroup>, keyof GMGroup>{};
diff --git a/shared/db/GMRecord.ts b/shared/db/GMRecord.ts
index 784a71056..193717003 100644
--- a/shared/db/GMRecord.ts
+++ b/shared/db/GMRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * GM用户组接口
@@ -29,3 +29,5 @@ export default class GMRecord extends BaseModel {
 }
 
 export const GMRecordModel = getModelForClass(GMRecord);
+
+export interface GMRecordType extends Pick<DocumentType<GMRecord>, keyof GMRecord>{};
\ No newline at end of file
diff --git a/shared/db/GMUser.ts b/shared/db/GMUser.ts
index 93e66a15f..c5ab0721a 100644
--- a/shared/db/GMUser.ts
+++ b/shared/db/GMUser.ts
@@ -1,7 +1,7 @@
 import { COUNTER } from './../consts';
 import { CounterModel } from './Counter';
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 const bcrypt = require('bcrypt');
 const SALT_WORK_FACTOR = 5
 
@@ -39,32 +39,32 @@ export default class GMUser extends BaseModel {
   }
   
   public static async getGmAccountList(lean = true) {
-    const user = await GMUserModel.find().select('uid username name token').lean(lean);
+    const user: GMUserType[] = await GMUserModel.find().select('uid username name token').lean(lean);
     return user;
   }
 
   public static async getGmAccountByToken(token: string, lean = true) {
     // console.log(token)
-    const user = await GMUserModel.findOne({token}).select('uid username name token').lean(lean);
+    const user: GMUserType = await GMUserModel.findOne({token}).select('uid username name token').lean(lean);
     return user;
   }
 
   public static async getGmAccountByUid(uid: number, lean = true) {
-    const user = await GMUserModel.findOne({uid}).select('uid username name token').lean(lean);
+    const user: GMUserType = await GMUserModel.findOne({uid}).select('uid username name token').lean(lean);
     return user;
   }
 
   public static async getGmAccountByUsername(username: string, lean = true) {
-    const user = await GMUserModel.findOne({username}).select('uid username name token').lean(lean);
+    const user: GMUserType = await GMUserModel.findOne({username}).select('uid username name token').lean(lean);
     return user;
   }
 
   public static async login(username: string, password: string, token: string, lean = true) {
-    const user = await GMUserModel.findOne({username}).select('salt').lean();
+    const user: GMUserType = await GMUserModel.findOne({username}).select('salt').lean();
     if(user) {
       let { salt } = user;
       let { npassword } = await this.encryptPass(password, salt);
-      const checkUser = await GMUserModel.findOneAndUpdate({username, password: npassword}, { token }).select('uid username name token').lean(lean);
+      const checkUser: GMUserType = await GMUserModel.findOneAndUpdate({username, password: npassword}, { token }).select('uid username name token').lean(lean);
       return checkUser;
     } else {
       return null
@@ -74,15 +74,17 @@ export default class GMUser extends BaseModel {
   public static async createGmAccount(username: string, password: string, name: string, token: string, lean = true) {
     const uid = await CounterModel.getNewCounter(COUNTER.GMUID);
     let r = await this.encryptPass(password);
-    const user = await GMUserModel.findOneAndUpdate({username}, {uid, password: r.npassword, salt: r.salt, name, token}, {upsert: true, new: true}).select('uid username name').lean(lean);
+    const user: GMUserType = await GMUserModel.findOneAndUpdate({username}, {uid, password: r.npassword, salt: r.salt, name, token}, {upsert: true, new: true}).select('uid username name').lean(lean);
     return user;
   }
 
   public static async changePass(uid: number, password: string, lean = true) {
     let r = await this.encryptPass(password);
-    const user = await GMUserModel.findOneAndUpdate({uid}, { password: r.npassword, salt: r.salt}).select('uid username name').lean(lean);
+    const user: GMUserType = await GMUserModel.findOneAndUpdate({uid}, { password: r.npassword, salt: r.salt}).select('uid username name').lean(lean);
     return user;
   }
 }
 
 export const GMUserModel = getModelForClass(GMUser);
+
+export interface GMUserType extends Pick<DocumentType<GMUser>, keyof GMUser>{};
diff --git a/shared/db/GMUserGroup.ts b/shared/db/GMUserGroup.ts
index ec917e533..0cfec75ce 100644
--- a/shared/db/GMUserGroup.ts
+++ b/shared/db/GMUserGroup.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 /**
   * GM账号和用户组关系接口
@@ -17,19 +17,21 @@ export default class GMUserGroup extends BaseModel {
   groupId: number;
 
   public static async getUserGroupByUid(uid: number, serverId: number, lean = true) {
-    const user = await GMUserGroupModel.find({uid, serverId}).lean(lean);
+    const user: GMUserGroupType[] = await GMUserGroupModel.find({uid, serverId}).lean(lean);
     return user;
   }
 
-  public static async removeUserGroup(uid: number, serverId: number, groups: Array<number>, lean = true) {
-    const user = await GMUserGroupModel.deleteMany({uid, serverId, groupId: {$in: groups}}).lean(lean);
+  public static async removeUserGroup(uid: number, serverId: number, groups: Array<number>) {
+    const user = await GMUserGroupModel.deleteMany({uid, serverId, groupId: {$in: groups}});
     return user;
   }
 
   public static async addUserGroup(uid: number, serverId: number, groupId: number, lean = true) {
-    const result = await GMUserGroupModel.findOneAndUpdate({uid, serverId, groupId}, {}, {new:true, upsert:true}).lean(lean);
+    const result: GMUserGroupType = await GMUserGroupModel.findOneAndUpdate({uid, serverId, groupId}, {}, {new:true, upsert:true}).lean(lean);
     return result;
   }
 }
 
 export const GMUserGroupModel = getModelForClass(GMUserGroup);
+
+export interface GMUserGroupType extends Pick<DocumentType<GMUserGroup>, keyof GMUserGroup>{};
\ No newline at end of file
diff --git a/shared/db/Game.ts b/shared/db/Game.ts
index d0311ab12..7c4df8684 100644
--- a/shared/db/Game.ts
+++ b/shared/db/Game.ts
@@ -1,6 +1,6 @@
 import { APP_ID } from './../consts';
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class ServerInfo {
   @prop({ required: true })
@@ -56,7 +56,7 @@ export default class Game extends BaseModel {
   versionCode: number;
 
   public static async getAllServerList() {
-    let game = await GameModel.findOne().lean();
+    let game: GameType = await GameModel.findOne().lean();
     if(game) {
       return game.serverList;
     } else {
@@ -65,7 +65,7 @@ export default class Game extends BaseModel {
   }
 
   public static async getServerListByType(serverType: string) {
-    let game = await GameModel.findOne().lean();
+    let game: GameType = await GameModel.findOne().lean();
     if (!game) {
       const serverInfo: ServerInfo = { id: 1, name: '常山少年', host: 'pinus_test.trgame.cn', port: 3014, status: 1, createTime: new Date(), serverType: 'official' };
       const iconUrl = `https://download.tgamebox.cn/avatar/${APP_ID}/1.png`;
@@ -84,9 +84,11 @@ export default class Game extends BaseModel {
 
   public static async newServer(serverId: number, serverType: string, name: string, host: string, port: number, status: number, lean = true) {
     let serverInfo: ServerInfo = {id: serverId, name, host, port, status, createTime: new Date(), serverType};
-    let game = await GameModel.findOneAndUpdate({}, {$push: {serverList: serverInfo}}, {new: true}).lean(lean);
+    let game: GameType = await GameModel.findOneAndUpdate({}, {$push: {serverList: serverInfo}}, {new: true}).lean(lean);
     return game;
   }
 }
 
 export const GameModel = getModelForClass(Game);
+
+export interface GameType extends Pick<DocumentType<Game>, keyof Game>{};
diff --git a/shared/db/HangUpRecord.ts b/shared/db/HangUpRecord.ts
index 9c7d2ea98..b68a893d2 100644
--- a/shared/db/HangUpRecord.ts
+++ b/shared/db/HangUpRecord.ts
@@ -1,6 +1,6 @@
 import { HANG_UP_CONSTS } from './../consts';
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class Goods {
   @prop({ required: true })
@@ -42,17 +42,17 @@ export default class HangUpRecord extends BaseModel {
     const curTime = new Date();
     const recDoc = new HangUpRecordModel();
     const update = Object.assign(recDoc.toJSON(), {roleId, roleName, startTime: curTime, startLv: HANG_UP_CONSTS.ENABLE_LV});
-    const rec = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: HANG_UP_CONSTS.ENABLE_LV}, update, {upsert: true, new: true}).lean(lean);
+    const rec: HangUpRecordType = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: HANG_UP_CONSTS.ENABLE_LV}, update, {upsert: true, new: true}).lean(lean);
     return rec;
   }
 
   public static async getCurRec(roleId: string, lean = true) {
-      const rec = await HangUpRecordModel.findOne({roleId, received: false}).lean(lean);
+      const rec: HangUpRecordType = await HangUpRecordModel.findOne({roleId, received: false}).lean(lean);
       return rec;
   }
 
   public static async getLastRec(roleId: string, lean = true) {
-    const rec = await HangUpRecordModel.findOne({roleId, received: true}).sort({endTime: -1}).lean(lean);
+    const rec: HangUpRecordType = await HangUpRecordModel.findOne({roleId, received: true}).sort({endTime: -1}).lean(lean);
     return rec;
 }
 
@@ -61,14 +61,16 @@ export default class HangUpRecord extends BaseModel {
     const recDoc = new HangUpRecordModel();
     const update = Object.assign(recDoc.toJSON(), {roleId, roleName, startTime: endTime, startLv: endLv});
     delete update._id;
-    const newRec = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: endLv, received: false}, update, {upsert: true, new: true}).lean(lean);
+    const newRec: HangUpRecordType = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: endLv, received: false}, update, {upsert: true, new: true}).lean(lean);
     return newRec;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await HangUpRecordModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await HangUpRecordModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const HangUpRecordModel = getModelForClass(HangUpRecord);
+
+export interface HangUpRecordType extends Pick<DocumentType<HangUpRecord>, keyof HangUpRecord>{};
diff --git a/shared/db/HangUpSpdUpRec.ts b/shared/db/HangUpSpdUpRec.ts
index 997a284a4..4715958ff 100644
--- a/shared/db/HangUpSpdUpRec.ts
+++ b/shared/db/HangUpSpdUpRec.ts
@@ -1,6 +1,6 @@
 // import { HANG_UP_CONSTS } from './../consts';
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class Goods {
   @prop({ required: true })
@@ -41,7 +41,7 @@ export default class HangUpSpdUpRec extends BaseModel {
 
   public static async updateRec(roleId, roleName, multi, lv, needReceiveGoods: Array<{gid:number, count: number}>, lean = true ) {
     if (multi <= 0) return null;
-    let rec = await HangUpSpdUpRecModel.findOneAndUpdate({roleId, lv, roleName}, {$inc: {cnt: multi}}, {upsert: true, new: true}).lean(lean);
+    let rec: HangUpSpdUpRecType = await HangUpSpdUpRecModel.findOneAndUpdate({roleId, lv, roleName}, {$inc: {cnt: multi}}, {upsert: true, new: true}).lean(lean);
     if(rec && needReceiveGoods.length > 0) {
       let {cnt} = rec;
       let goods = [{
@@ -53,11 +53,13 @@ export default class HangUpSpdUpRec extends BaseModel {
     return rec;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await HangUpSpdUpRecModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await HangUpSpdUpRecModel.deleteMany({roleId});
+    return result;
   }
 
 }
 
 export const HangUpSpdUpRecModel = getModelForClass(HangUpSpdUpRec);
+
+export interface HangUpSpdUpRecType extends Pick<DocumentType<HangUpSpdUpRec>, keyof HangUpSpdUpRec>{};
diff --git a/shared/db/Hero.ts b/shared/db/Hero.ts
index 85f092f3c..fa8e510ab 100644
--- a/shared/db/Hero.ts
+++ b/shared/db/Hero.ts
@@ -1,5 +1,6 @@
-import BaseModel, { CeAttr } from './BaseModel';
-import { index, getModelForClass, prop, Ref, mongoose } from '@typegoose/typegoose';
+import BaseModel from './BaseModel';
+import { CeAttr } from './generalField';
+import { index, getModelForClass, prop, Ref, mongoose, DocumentType } from '@typegoose/typegoose';
 import Equip from './Equip';
 import { CounterModel } from './Counter';
 import { COUNTER } from '../consts';
@@ -35,7 +36,7 @@ interface heroUpdate {
     favour?:number;
     favourLv?:number;
     skins?: Skin[];
-    conections?: Connect[];
+    connections?: Connect[];
     _id?:number;
 }
 
@@ -98,25 +99,25 @@ export default class Hero extends BaseModel {
     equips: Ref<Equip>[]; // 武将装备引用数组
 
     public static async findByRole(roleId: string, lean = true) {
-        const heros = await HeroModel.find({ roleId }).populate('equips').lean(lean);
-        return heros || [];
+        const heros: HeroType[] = await HeroModel.find({ roleId }).populate('equips').lean(lean);
+        return heros;
     }
 
     public static async findBySeqIdRange(seqIds: Array<number>, roleId: string, lean = true) {
-        const hero = await HeroModel.find({ seqId: {$in: seqIds}, roleId }).lean(lean);
+        const hero: HeroType[] = await HeroModel.find({ seqId: {$in: seqIds}, roleId }).lean(lean);
         return hero;
     }
     public static async findBySeqIdAndRole(seqId: number, roleId: string, lean = true) {
-        const hero = await HeroModel.findOne({ seqId, roleId }).lean(lean);
+        const hero: HeroType = await HeroModel.findOne({ seqId, roleId }).lean(lean);
         return hero;
     }
     public static async findByHidAndRole(hid: number, roleId: string, lean = true) {
-        const hero = await HeroModel.findOne({ hid, roleId }).lean(lean);
+        const hero: HeroType = await HeroModel.findOne({ hid, roleId }).lean(lean);
         return hero;
     }
 
     public static async addEquip(roleId: string, hid: number, equipId: string, lean = true) {
-        const hero = await HeroModel.findOneAndUpdate({ roleId, hid }, {$push: {equips: equipId}}, {new: true}).lean(lean);
+        const hero: HeroType = await HeroModel.findOneAndUpdate({ roleId, hid }, {$push: {equips: equipId}}, {new: true}).lean(lean);
         if (hero) {
         await Equip.putOn(hero.hid, equipId);
         }
@@ -128,12 +129,12 @@ export default class Hero extends BaseModel {
         const seqId = await CounterModel.getNewCounter(COUNTER.HID)||-1;
         const update = Object.assign(doc.toJSON(), heroInfo, {seqId});
         delete update._id;
-        const hero = await HeroModel.findOneAndUpdate({roleId: heroInfo.roleId, hid: heroInfo.hid}, update, {upsert: true, new: true}).select('hid hName lv exp star starStage colorStar colorStarStage quality job jobStage conections favour favourLv skins equips ce ceAttr').lean(lean);
+        const hero: HeroType = await HeroModel.findOneAndUpdate({roleId: heroInfo.roleId, hid: heroInfo.hid}, update, {upsert: true, new: true}).select('hid hName lv exp star starStage colorStar colorStarStage quality job jobStage conections favour favourLv skins equips ce ceAttr').lean(lean);
         return hero;
     }
 
     public static async sumTopHeroCe(roleId: string, num: number) {
-        let ce = await HeroModel.aggregate([
+        let ce: Array<{historyCe: number}> = await HeroModel.aggregate([
         { $match : { roleId } },
         { $sort: {historyCe: -1} },
         { $limit: num },
@@ -143,7 +144,7 @@ export default class Hero extends BaseModel {
     }
 
     public static async sumHeroCe(roleId: string) {
-        let ce = await HeroModel.aggregate([
+        let ce: Array<{ce: number}> = await HeroModel.aggregate([
         { $match : { roleId } },
         { $group: { _id: null, ce: { $sum: '$ce' } } }
         ]);
@@ -151,29 +152,30 @@ export default class Hero extends BaseModel {
     }
 
     public static async getTopHero(roleId: string, num: number, lean = true) {
-        const heroes = await HeroModel.find({roleId}).limit(num).sort({ce: -1}).lean(lean);
+        const heroes: HeroType[] = await HeroModel.find({roleId}).limit(num).sort({ce: -1}).lean(lean);
         return heroes;
     }
 
     public static async updateCe(roleId: string, hid: number, ce: number, oldCe: number, historyCe: number, lean = true) {
         let distance = ce - oldCe;
         let historyDistance = ce > historyCe ?ce - historyCe: 0;
-        let result = await HeroModel.findOneAndUpdate({roleId, hid}, {$inc:{ce: distance, historyCe: historyDistance}}).lean(lean);
-        return result||{};
+        let result: HeroType = await HeroModel.findOneAndUpdate({roleId, hid}, {$inc:{ce: distance, historyCe: historyDistance}}).lean(lean);
+        return result;
     }
 
-    public static async deleteAccount(roleId: string, lean = true) {
-        let result = await HeroModel.deleteMany({roleId}).lean(lean);
-        return result||{};
+    public static async deleteAccount(roleId: string) {
+        let result = await HeroModel.deleteMany({roleId});
+        return result;
     }
 
     public static async updateHeroInfo(roleId: string, hid:number, heroUpdate:heroUpdate, lean = true) {
         delete heroUpdate._id;
-        let result = await HeroModel.findOneAndUpdate({roleId, hid}, {$set:heroUpdate}).lean(lean);
-        return result||{};
+        let result: HeroType = await HeroModel.findOneAndUpdate({roleId, hid}, {$set:heroUpdate}).lean(lean);
+        return result;
     }
 
 }
 
 export const HeroModel = getModelForClass(Hero);
- 
\ No newline at end of file
+ 
+export interface HeroType extends Pick<DocumentType<Hero>, keyof Hero>{};
diff --git a/shared/db/Item.ts b/shared/db/Item.ts
index 4e57455e0..d565ce517 100644
--- a/shared/db/Item.ts
+++ b/shared/db/Item.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 @index({ roleId: 1, id: 1 })
 @index({ seqId: 1 })
@@ -22,36 +22,36 @@ export default class Item extends BaseModel {
 
 
   public static async findbyRole(roleId: string, lean = true) {
-    const items = await ItemModel.find({ roleId }).select('id count type').lean(lean);
+    const items: ItemType[] = await ItemModel.find({ roleId }).select('id count type').lean(lean);
     return items;
   }
 
   public static async findbyRoleAndIds(roleId: string, ids: Array<number>, lean = true) {
-    const items = await ItemModel.find({ roleId, id: {$in: ids} }).select('id count type').lean(lean);
+    const items: ItemType[] = await ItemModel.find({ roleId, id: {$in: ids} }).select('id count type').lean(lean);
     return items;
   }
 
   public static async findByRoleAndType(roleId: string, type: number, lean = true) {
-    const items = await ItemModel.find({ roleId, type }).select('id count type').sort({id: 1}).lean(lean);
+    const items: ItemType[] = await ItemModel.find({ roleId, type }).select('id count type').sort({id: 1}).lean(lean);
     return items;
   }
 
   public static async findbyRoleAndGidAndCount(roleId: string, id: number, count: number, lean = true) {
-    const items = await ItemModel.findOne({ roleId, id, count: {$gte: count} }).select('id count type').lean(lean);
+    const items: ItemType = await ItemModel.findOne({ roleId, id, count: {$gte: count} }).select('id count type').lean(lean);
     return items;
   }
 
   public static async increaseItem(roleId: string, id: number, count: number, itemInfo: {roleId: string, roleName: string, id: number, itemName: string, type: number, hid?: number }, lean = true) {
     const doc = new ItemModel();
     const setOnInsert = Object.assign(doc.toJSON(), itemInfo);
-    const equips = await ItemModel.findOneAndUpdate({roleId, id },{$setOnInsert: setOnInsert, $inc: { count }}, {new: true, upsert: true}).lean(lean);
+    const equips: ItemType = await ItemModel.findOneAndUpdate({roleId, id },{$setOnInsert: setOnInsert, $inc: { count }}, {new: true, upsert: true}).lean(lean);
     return equips;
   }
 
   public static async decreaseItems(roleId: string, items: Array<{id: number, count: number}>, lean = true) {
     let updateItems = new Array<{id: number, count: number}>(), hasError: boolean = false, result = new Array();
     for(let {id, count} of items) {    
-      const rec = await ItemModel.findOneAndUpdate({roleId, id, count: {$gte: count} },{ $inc: { count: -1 * count }}, {new: true}).lean(lean);
+      const rec: ItemType = await ItemModel.findOneAndUpdate({roleId, id, count: {$gte: count} },{ $inc: { count: -1 * count }}, {new: true}).lean(lean);
       if(rec) {
         result.push(rec);
         updateItems.push({id, count});
@@ -69,10 +69,12 @@ export default class Item extends BaseModel {
     }
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await ItemModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await ItemModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const ItemModel = getModelForClass(Item);
+
+export interface ItemType extends Pick<DocumentType<Item>, keyof Item>{};
\ No newline at end of file
diff --git a/shared/db/PvpDefense.ts b/shared/db/PvpDefense.ts
index 8ac01bf55..572fb476e 100644
--- a/shared/db/PvpDefense.ts
+++ b/shared/db/PvpDefense.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class Heroes {
     @prop({ required: true })
@@ -36,25 +36,25 @@ export default class PvpDefense extends BaseModel {
 
 
   public static async findByRoleId(roleId: string, lean = true) {
-    const result = await PvpDefenseModel.findOne({ roleId }).lean(lean);
+    const result: PvpDefenseType = await PvpDefenseModel.findOne({ roleId }).lean(lean);
     return result;
   }
 
   public static async findByScale(roleId: string, min: number, max: number, lean = true) {
-    const result = await PvpDefenseModel.find({ roleId: {$ne: roleId}, ce: { $lte: max, $gte: min } }).sort({updatedAt: -1}).limit(100).lean(lean);
+    const result: PvpDefenseType[] = await PvpDefenseModel.find({ roleId: {$ne: roleId}, ce: { $lte: max, $gte: min } }).sort({updatedAt: -1}).limit(100).lean(lean);
     return result;
   }
 
   public static async createPvpDefense(params: {roleId: string, roleName: string, heroes: Array<any>, ce: number}, lean=true) {
     const doc = new PvpDefenseModel();
     const update = Object.assign(doc.toJSON(), params);
-    const defense = await PvpDefenseModel.findOneAndUpdate({ roleId: params.roleId }, update, {upsert: true, new: true}).lean(lean);
+    const defense: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId: params.roleId }, update, {upsert: true, new: true}).lean(lean);
     return defense;
 
   }
 
   public static async addHeroToDefense(roleId: string, heroInfo: any, ce: number, lean=true) {
-    const defense = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
+    const defense: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
       $inc: {ce},
       $push: { heroes: heroInfo }
     }, {upsert: true, new: true}).lean(lean);
@@ -63,7 +63,7 @@ export default class PvpDefense extends BaseModel {
   }
 
   public static async removeHeroFromDefense(roleId: string, hid: number, ce: number, lean=true) {
-    const defense = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
+    const defense: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
       $inc: {ce: -1 * ce},
       $pull: { heroes: { actorId: hid }}
     }, {upsert: true, new: true}).lean(lean);
@@ -73,14 +73,16 @@ export default class PvpDefense extends BaseModel {
 
   public static async updateCe(roleId: string, hid: number, ce: number, oldCe: number, lean = true) {
     let distance = ce - oldCe;
-    const rec = await PvpDefenseModel.findOneAndUpdate({roleId, 'heroes.actorId': hid}, {$inc: {ce: distance}}).lean(lean);
+    const rec: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({roleId, 'heroes.actorId': hid}, {$inc: {ce: distance}}).lean(lean);
     return rec
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await PvpDefenseModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await PvpDefenseModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const PvpDefenseModel = getModelForClass(PvpDefense);
+
+export interface PvpDefenseType extends Pick<DocumentType<PvpDefense>, keyof PvpDefense>{};
\ No newline at end of file
diff --git a/shared/db/RScriptRecord.ts b/shared/db/RScriptRecord.ts
index 1c6c9c08a..75274a2a9 100644
--- a/shared/db/RScriptRecord.ts
+++ b/shared/db/RScriptRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 
 @index({ roleId: 1, battleId: 1 })
@@ -28,19 +28,21 @@ export default class RScriptRecord extends BaseModel {
         update['scriptAfter'] = script;
       }
       
-    const items = await RScriptRecordModel.findOneAndUpdate({ roleId, battleId }, update, {upsert: true, new: true}).lean(lean);
+    const items: RScriptRecordType = await RScriptRecordModel.findOneAndUpdate({ roleId, battleId }, update, {upsert: true, new: true}).lean(lean);
     return items;
   }
 
   public static async findbyRoleAndBattle(roleId: string, battleId: number, lean = true) {
-    const items = await RScriptRecordModel.findOne({ roleId, battleId }).select('battleId scriptBefore scriptAfter').sort({battleId: 1}).lean(lean);
+    const items: RScriptRecordType = await RScriptRecordModel.findOne({ roleId, battleId }).select('battleId scriptBefore scriptAfter').sort({battleId: 1}).lean(lean);
     return items;
   }
 
   public static async findbyRole(roleId: string, warType: number, lean = true) {
-    const items = await RScriptRecordModel.find({ roleId, warType }).select('battleId scriptBefore scriptAfter').lean(lean);
+    const items: RScriptRecordType[] = await RScriptRecordModel.find({ roleId, warType }).select('battleId scriptBefore scriptAfter').lean(lean);
     return items;
   }
 }
 
 export const RScriptRecordModel = getModelForClass(RScriptRecord);
+
+export interface RScriptRecordType extends Pick<DocumentType<RScriptRecord>, keyof RScriptRecord>{};
\ No newline at end of file
diff --git a/shared/db/Role.ts b/shared/db/Role.ts
index 00d174898..e6874d968 100644
--- a/shared/db/Role.ts
+++ b/shared/db/Role.ts
@@ -1,6 +1,7 @@
 import { HANG_UP_CONSTS } from './../consts';
-import BaseModel, { CeAttr }  from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import BaseModel  from './BaseModel';
+import { CeAttr } from './generalField';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import User from './User';
 import { shouldRefresh } from '../pubUtils/util';
 import { HeroModel } from './Hero';
@@ -162,12 +163,12 @@ export default class Role extends BaseModel {
     dungeonHeroes: Array<DungeonHero>;		// 秘境首通使用的武将
     
     public static async findByUid(uid: number, serverId: number, lean = true) {
-        const role = await RoleModel.findOne({ 'userInfo.uid': uid, serverId }).lean(lean);
+        const role: RoleType = await RoleModel.findOne({ 'userInfo.uid': uid, serverId }).lean(lean);
         return role;
     }
 
     public static async findByRoleId(roleId: string, lean = true) {
-        const role = await RoleModel.findOne({ roleId }).lean(lean);
+        const role: RoleType = await RoleModel.findOne({ roleId }).lean(lean);
         return role;
     }
 
@@ -176,7 +177,7 @@ export default class Role extends BaseModel {
         if (!user) return null;
         const doc = new RoleModel();
         const update = Object.assign(doc.toJSON(), roleInfo, { userInfo: user, serverType: user.serverType, serverId });
-        const role = await RoleModel.findOneAndUpdate({ 'userInfo.uid': uid, serverId }, update, { upsert: true, new: true }).lean(lean);
+        const role: RoleType = await RoleModel.findOneAndUpdate({ 'userInfo.uid': uid, serverId }, update, { upsert: true, new: true }).lean(lean);
         return role;
     }
 
@@ -188,17 +189,18 @@ export default class Role extends BaseModel {
         };
         }
         //.select('uid tel username')
-        const user = await RoleModel.find(searchObj).lean(lean);
+        const user: RoleType[] = await RoleModel.find(searchObj).lean(lean);
         return user;
     }
 
 
     public static async setEventStatus(roleId: string, eventStatus: number, lean = true) {
-        await RoleModel.findOneAndUpdate({ roleId }, { eventStatus }, {new: true}).lean(lean);
+        let role: RoleType = await RoleModel.findOneAndUpdate({ roleId }, { eventStatus }, {new: true}).lean(lean);
+        return role;
     }
     
     public static async towerLvUp(roleId: string, lean = true) {
-        let role = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerLv: 1}, towerUpTime: new Date()}, {new: true}).lean(lean);
+        let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerLv: 1}, towerUpTime: new Date()}, {new: true}).lean(lean);
         return role;
     }
 
@@ -207,7 +209,7 @@ export default class Role extends BaseModel {
 
         const result = await RoleModel.findOne({roleId}).lean(lean);
         const lastSpdUpTime = result?.lastSpdUpTime;
-        let role = null;
+        let role: RoleType;
         if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime, HANG_UP_CONSTS.REFRESH_TIME, 1) && cnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
         role = await RoleModel.findOneAndUpdate({roleId}, {hangUpSpdUpCnt: HANG_UP_CONSTS.MAX_SPD_UP_CNT - cnt, lastSpdUpTime: curTime}, {new: true}).lean(lean);
         } else {
@@ -217,47 +219,47 @@ export default class Role extends BaseModel {
     }
 
     public static async increaseExpeditionPoint(roleId: string, point: number, lean = true) {
-        let role = await RoleModel.findOneAndUpdate({roleId}, {$inc: { expeditionPoint: point }}, {new: true}).lean(lean);
+        let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: { expeditionPoint: point }}, {new: true}).lean(lean);
         return role;
     }
 
     public static async levelup(roleId: string, lv: number, exp: number, lean = true) {
-        let role = await RoleModel.findOneAndUpdate({roleId}, {$set: { exp, lv }}, {new: true}).lean(lean);
+        let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$set: { exp, lv }}, {new: true}).lean(lean);
         return role;
     }
 
-    public static async deleteAccount(roleId: string, lean = true) {
-        let result = await RoleModel.deleteMany({roleId}).lean(lean);
-        return result||{};
+    public static async deleteAccount(roleId: string) {
+        let result = await RoleModel.deleteMany({roleId});
+        return result;
     }
         
     public static async addCoin(roleId: string, cnt: number, lean = true) {
-        let result = await RoleModel.findOneAndUpdate({roleId}, { $inc: {coin: cnt} }, { "new": true, "upsert": true}).lean(lean);
+        let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, { $inc: {coin: cnt} }, { "new": true, "upsert": true}).lean(lean);
         return result;
     }
 
     public static async addGoldFree(roleId: string, cnt: number, lean = true) {
-        let result = await RoleModel.findOneAndUpdate({roleId}, { $inc: { gold: cnt, giftGold: cnt } }, { "new": true, "upsert": true}).lean(lean);
+        let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, { $inc: { gold: cnt, giftGold: cnt } }, { "new": true, "upsert": true}).lean(lean);
         return result;
     }
 
     public static async costCoin(roleId: string, cnt: number, lean = true) {
-        let result = await RoleModel.findOneAndUpdate({roleId, coin: {$gte: cnt}}, { $inc: { coin: -cnt } }, { "new": true}).lean(lean);
+        let result: RoleType = await RoleModel.findOneAndUpdate({roleId, coin: {$gte: cnt}}, { $inc: { coin: -cnt } }, { "new": true}).lean(lean);
         return result;
     }
 
     public static async costGold(roleId: string, cnt: number, lean = true) {
-        let result = await RoleModel.findOneAndUpdate({roleId, gold: {$gte: cnt}}, { $inc: { gold: -cnt, totalCost: cnt } }, { "new": true}).lean(lean);
+        let result: RoleType = await RoleModel.findOneAndUpdate({roleId, gold: {$gte: cnt}}, { $inc: { gold: -cnt, totalCost: cnt } }, { "new": true}).lean(lean);
         return result;
     }
 
     public static async pushWarStar(roleId: string, battleId: number, warType: number, star: number, lean = true) {
-        let result = await RoleModel.findOneAndUpdate({roleId}, { $addToSet: { warStar: {id: battleId, warType, star }} }, { "new": true, "upsert": true}).lean(lean);
+        let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, { $addToSet: { warStar: {id: battleId, warType, star }} }, { "new": true, "upsert": true}).lean(lean);
         return result;
     }
 
     public static async updateWarStar(roleId: string, battleId: number, star: number, lean = true) {
-        let result = await RoleModel.findOneAndUpdate(
+        let result: RoleType = await RoleModel.findOneAndUpdate(
         {roleId, 'warStar.id': battleId}, 
         { $set: { 'warStar.$.star': star } }, 
         { "new": true, "upsert": true}
@@ -267,24 +269,24 @@ export default class Role extends BaseModel {
 
     // 重置派遣次数
     public static async resetTowerCnt(roleId: string, curTime: Date, lean = true) {
-        const role = await RoleModel.findOneAndUpdate({roleId}, {towerTaskCnt: 0, towerTaskRefTime: curTime, towerTaskReCnt: 0}, {new: true}).lean(lean);
+        const role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {towerTaskCnt: 0, towerTaskRefTime: curTime, towerTaskReCnt: 0}, {new: true}).lean(lean);
         return role;
     }
     // 刷新派遣任务次数增长
     public static async increaseTowerCnt(roleId: string, num: number, lean = true) {
-        const role = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskCnt: num}}, {new: true}).lean(lean);
+        const role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskCnt: num}}, {new: true}).lean(lean);
         return role;
     }
     // 派遣任务增加刷新次数
     public static async increaseTowerRefCnt(roleId: string, num: number, lean = true) {
-        const role = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskReCnt: num}}, {new: true}).lean(lean);
+        const role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskReCnt: num}}, {new: true}).lean(lean);
         return role;
     }
 
     // 刷新远征重置次数
     public static async increaseExpeditionResetCnt(roleId: string, needRefresh: boolean, curTime: Date, lean = true) {
 
-        let role = null;
+        let role: RoleType;
         if (needRefresh) {
         role = await RoleModel.findOneAndUpdate({roleId}, {expeditionResetCnt: 1, expeditionResetRefTime: curTime}, {new: true}).lean(lean);
         } else {
@@ -297,7 +299,7 @@ export default class Role extends BaseModel {
     // 购买次数
     public static async buyCnt(roleId: string, needRefresh: boolean, inc: number, curTime: Date, lean = true) {    console.log('&*&*&*&*&')
 
-        let role = null;
+        let role: RoleType;
         if (needRefresh) {
         role = await RoleModel.findOneAndUpdate({roleId}, {dungeonCnt: 0, dungeonRefTime: curTime, dungeonBuyCnt: inc}, {new: true}).lean(lean);
         } else {
@@ -308,7 +310,7 @@ export default class Role extends BaseModel {
 
     // 增加次数
     public static async increaseDungeonCnt(roleId: string, needRefresh: boolean, inc: number, curTime: Date, lean = true) {
-        let role = null;
+        let role: RoleType;
         if (needRefresh) {
         role = await RoleModel.findOneAndUpdate({roleId}, {dungeonCnt: inc, dungeonRefTime: curTime, dungeonBuyCnt: 0}, {new: true}).lean(lean);
         } else {
@@ -324,7 +326,7 @@ export default class Role extends BaseModel {
         sortBy['towerLv'] = -1;
         sortBy['towerUpTime'] = 1;
         }
-        const ranks = await RoleModel.find({serverId}).select(fields.join(' ')).sort(sortBy).limit(limit).skip((page - 1) * limit).lean(lean);
+        const ranks: RoleType[] = await RoleModel.find({serverId}).select(fields.join(' ')).sort(sortBy).limit(limit).skip((page - 1) * limit).lean(lean);
         return ranks;
     }
 
@@ -359,32 +361,36 @@ export default class Role extends BaseModel {
         let topFiveCe = topFive.reduce((pre, cur) => {
         return pre + cur.ce
         }, 0);
-        await RoleModel.findOneAndUpdate({roleId}, { topFive, topFiveCe, $inc: {ce: distance} }).lean(lean);
+        role = await RoleModel.findOneAndUpdate({roleId}, { topFive, topFiveCe, $inc: {ce: distance} }).lean(lean);
+        return role;
     }
 
     // 保存秘境首通队伍
     public static async saveDungeonHero(roleId: string, battleId: number, heroes: Array<number>, isSuccess: boolean) {
         if(isSuccess) {
-        const role = await Role.findByRoleId(roleId);
-        let dungeonHeroes = role && role.dungeonHeroes;
-        let hasHero = dungeonHeroes&&dungeonHeroes.find(cur => cur.battleId == battleId);
-        if(!dungeonHeroes || !hasHero) {
-            await RoleModel.findOneAndUpdate({roleId}, {$push:{dungeonHeroes: {battleId, heroes}}})
-        }
+            let role = await Role.findByRoleId(roleId);
+            let dungeonHeroes = role && role.dungeonHeroes;
+            let hasHero = dungeonHeroes&&dungeonHeroes.find(cur => cur.battleId == battleId);
+            if(!dungeonHeroes || !hasHero) {
+                role = await RoleModel.findOneAndUpdate({roleId}, {$push:{dungeonHeroes: {battleId, heroes}}})
+            }
+            return role;
         }
     }
 
     // 保存开启功能
     public static async pushFuncs(roleId: string, funcs: Array<number>, lean = true) {
-        const recs = await RoleModel.findOneAndUpdate({roleId}, {$push: {funcs: {$each: funcs}}}, {new: true}).lean(lean);
+        const recs: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$push: {funcs: {$each: funcs}}}, {new: true}).lean(lean);
         return recs
     }
 
     public static async updateRoleInfo(roleId: string, roleUpdate:roleUpdate, lean = true) {
         delete roleUpdate._id;
-        let result = await RoleModel.findOneAndUpdate({roleId}, {$set:roleUpdate}).lean(lean);
-        return result||{};
+        let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$set:roleUpdate}).lean(lean);
+        return result;
     }
 }
 
 export const RoleModel = getModelForClass(Role);
+
+export interface RoleType extends Pick<DocumentType<Role>, keyof Role>{};
diff --git a/shared/db/SearchRecord.ts b/shared/db/SearchRecord.ts
index 63c08377e..95a43c703 100644
--- a/shared/db/SearchRecord.ts
+++ b/shared/db/SearchRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class SearchTask {
   @prop({ required: true })
@@ -28,10 +28,12 @@ export default class SearchRecord extends BaseModel {
   tasks: Array<SearchTask>;
 
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await SearchRecordModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await SearchRecordModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const SearchRecordModel = getModelForClass(SearchRecord);
+
+export interface SearchRecordType extends Pick<DocumentType<SearchRecord>, keyof SearchRecord>{};
\ No newline at end of file
diff --git a/shared/db/Sms.ts b/shared/db/Sms.ts
index 6942c1cb7..4fb131daa 100644
--- a/shared/db/Sms.ts
+++ b/shared/db/Sms.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 const moment = require('moment');
 
 /**
@@ -27,16 +27,17 @@ export default class Sms extends BaseModel {
   countToday: number;
 
   public static async findByTel(tel: string, lean = true) {
-    const sms = await smsModel.findOne({ tel }).lean(lean);
+    const sms: SmsType = await smsModel.findOne({ tel }).lean(lean);
     return sms;
   }
 
   public static async updateByTel(tel: string, code: string, used: boolean, updateTime: Date, countToday: number, lean = true) {
-    await smsModel.findOneAndUpdate({ tel }, { code, used, updateTime, countToday }, { upsert: true }).lean(lean);
+    const sms: SmsType = await smsModel.findOneAndUpdate({ tel }, { code, used, updateTime, countToday }, { upsert: true }).lean(lean);
+    return sms;
   }
 
   public static async validateSms(tel: string, code: string, lean = true) {
-    const record = await smsModel.findOneAndUpdate({ tel, code, used: false }, { used: true }).lean(lean);
+    const record: SmsType = await smsModel.findOneAndUpdate({ tel, code, used: false }, { used: true }).lean(lean);
     return !!record;
   }
 
@@ -63,3 +64,5 @@ export default class Sms extends BaseModel {
 }
 
 export const smsModel = getModelForClass(Sms);
+
+export interface SmsType extends Pick<DocumentType<Sms>, keyof Sms>{};
\ No newline at end of file
diff --git a/shared/db/TowerRecord.ts b/shared/db/TowerRecord.ts
index b6c3dba67..c90444642 100644
--- a/shared/db/TowerRecord.ts
+++ b/shared/db/TowerRecord.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 class WarStatus {
   @prop({ required: true })
@@ -38,7 +38,7 @@ export default class TowerRecord extends BaseModel {
     const update = Object.assign(recDoc.toJSON(), towerInfo );
     const { roleId, lv } = towerInfo;
     // console.log(JSON.stringify(towerInfo))
-    let rec = await TowerRecordModel.findOneAndUpdate({roleId, lv}, {$set: update}, {upsert: true, new: true}).lean(lean);
+    let rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate({roleId, lv}, {$set: update}, {upsert: true, new: true}).lean(lean);
     return rec;
   }
 
@@ -54,7 +54,7 @@ export default class TowerRecord extends BaseModel {
   public static async updateRecord(roleId: string, lv: number, battleCode: string, warId: number, heroes: Array<number>, inc: number, lean = true) {
     let tower = await TowerRecordModel.findOne({roleId, lv, 'warStatus.warId': warId});
     if(tower) {
-      const rec = await TowerRecordModel.findOneAndUpdate(
+      const rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate(
         {roleId, lv, 'warStatus.warId': warId},
         {$set: {'warStatus.$.status': true, 'warStatus.$.battleCode': battleCode, passed: inc === 1 ? true : false}, $push: {heroes: {$each: heroes}}},
         {new: true, upsert: true}
@@ -62,7 +62,7 @@ export default class TowerRecord extends BaseModel {
       return rec;
     } else {
       let warStatus = [{warId, status: true,battleCode, passed: inc === 1 ? true : false}];
-      const rec = await TowerRecordModel.findOneAndUpdate(
+      const rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate(
         {roleId, lv},
         { $push: {heroes: {$each: heroes}, warStatus: {$each: warStatus}}},
         {new: true, upsert: true}
@@ -73,12 +73,12 @@ export default class TowerRecord extends BaseModel {
 
 
   public static async getRecordByLv(roleId: string, lv: number, lean = true) {
-    const rec = await TowerRecordModel.findOne({roleId, lv}).lean(lean);
+    const rec: TowerRecordType = await TowerRecordModel.findOne({roleId, lv}).lean(lean);
     return rec;
   }
 
   public static async resetRecordByLv(roleId: string, lv: number, lean = true) {
-    const rec = await TowerRecordModel.findOneAndUpdate(
+    const rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate(
       {roleId, lv, passed: false},
       {$set: {'warStatus.$[].status': false, 'warStatus.$[].battleCode': '', heroes: []}},
       {new: true}).lean(lean);
@@ -86,10 +86,12 @@ export default class TowerRecord extends BaseModel {
   }
 
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await TowerRecordModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await TowerRecordModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const TowerRecordModel = getModelForClass(TowerRecord);
+
+export interface TowerRecordType extends Pick<DocumentType<TowerRecord>, keyof TowerRecord>{};
\ No newline at end of file
diff --git a/shared/db/TowerTaskRec.ts b/shared/db/TowerTaskRec.ts
index 8d0140712..3cfdda13b 100644
--- a/shared/db/TowerTaskRec.ts
+++ b/shared/db/TowerTaskRec.ts
@@ -1,5 +1,5 @@
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
 function genCodeTmp(len) {
   const chars = '123456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijklmnopqrstuvwxyz';
@@ -43,7 +43,7 @@ export default class TowerTaskRec extends BaseModel {
   completeTime: Date; // 派遣结束时间
 
   public static async getCurTasks(roleId: string, lean = true) {
-    const recs = await TowerTaskRecModel.find({roleId, refreshStatus: 1}).sort({createdAt: 1}).lean(lean);
+    const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({roleId, refreshStatus: 1}).sort({createdAt: 1}).lean(lean);
     return recs;
   }
 
@@ -59,14 +59,14 @@ export default class TowerTaskRec extends BaseModel {
   }
 
   public static async getTasksByCode(batchCode: string, lean = true) {
-    const recs = await TowerTaskRecModel.find({batchCode}).lean(lean);
+    const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({batchCode}).lean(lean);
     return recs;
   }
 
   public static async sendHeroes(_roleId: string, batchCode: string, tasks: Array<{taskCode:string, heroes: Array<number>, completeTime: number}>, sendTime: Date, lean = true) {
     let recs = new Array();
     for (let {taskCode, heroes, completeTime} of tasks) {
-      const rec = await TowerTaskRecModel.findOneAndUpdate(
+      const rec: TowerTaskRecType = await TowerTaskRecModel.findOneAndUpdate(
         {batchCode, taskCode: taskCode, refreshStatus: 1},
         {heroes: heroes, status: 1, sendTime, completeTime: new Date(sendTime.getTime() + completeTime * 1000)},
         {new: true}).lean(lean);
@@ -76,32 +76,34 @@ export default class TowerTaskRec extends BaseModel {
     return recs;
   }
 
-  public static async finishTask(batchCode: string, tasks: Array<string>, lean = true) {
-    const recs = await TowerTaskRecModel.updateMany({batchCode, taskCode: {$in:tasks}}, {status: 3, refreshStatus: -1}).lean(lean);
+  public static async finishTask(batchCode: string, tasks: Array<string>, _lean = true) {
+    const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({batchCode, taskCode: {$in:tasks}}, {status: 3, refreshStatus: -1});
     return recs;
   }
 
   // 将隐藏的任务显示出来 0=>1
-  public static async showTask(roleId: string, bactchCode: string, num: number, lean = true) {
-    const recs = await TowerTaskRecModel.updateMany({roleId, refreshStatus: 0}, {bactchCode, refreshStatus: 1}).sort({createdAt: 1}).limit(num).lean(lean);
+  public static async showTask(roleId: string, bactchCode: string, num: number, _lean = true) {
+    const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({roleId, refreshStatus: 0}, {bactchCode, refreshStatus: 1}).sort({createdAt: 1}).limit(num);
     return recs;
   }
   // 刷掉旧任务 1=>-1
-  public static async hideTask(roleId: string, taskIds: Array<string>, lean = true) {
+  public static async hideTask(roleId: string, taskIds: Array<string>, _lean = true) {
     // console.log(refTime)
-    const recs = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}, refreshStatus: 1}, {refreshStatus: -1}).lean(lean);
+    const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}, refreshStatus: 1}, {refreshStatus: -1});
     return recs;
   }
 
-  public static async updateBatchCode(roleId: string, taskIds: Array<string>, batchCode: string, lean = true) {
-    const recs = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}}, {batchCode}).lean(lean);
+  public static async updateBatchCode(roleId: string, taskIds: Array<string>, batchCode: string, _lean = true) {
+    const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}}, {batchCode});
     return recs;
   }
 
-  public static async deleteAccount(roleId: string, lean = true) {
-    let result = await TowerTaskRecModel.deleteMany({roleId}).lean(lean);
-    return result||{};
+  public static async deleteAccount(roleId: string) {
+    let result = await TowerTaskRecModel.deleteMany({roleId});
+    return result;
   }
 }
 
 export const TowerTaskRecModel = getModelForClass(TowerTaskRec);
+
+export interface TowerTaskRecType extends Pick<DocumentType<TowerTaskRec>, keyof TowerTaskRec>{};
\ No newline at end of file
diff --git a/shared/db/User.ts b/shared/db/User.ts
index 53c0c06bf..b8210391a 100644
--- a/shared/db/User.ts
+++ b/shared/db/User.ts
@@ -1,7 +1,7 @@
 import { COUNTER } from './../consts';
 import { CounterModel } from './Counter';
 import BaseModel from './BaseModel';
-import { index, getModelForClass, prop } from '@typegoose/typegoose';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { genCode } from '../pubUtils/util';
 
 /**
@@ -68,7 +68,7 @@ export default class User extends BaseModel {
   auth: number;
 
   public static async updateToken(tel: string, token: string, platform: string, pkgName: string, serverType: string, lean = true) {
-    let user = await UserModel.findOne({ tel }).lean();
+    let user: UserType = await UserModel.findOne({ tel }).lean();
     const curTime: Date = new Date();
     let update = {};
     if (!user) {
@@ -83,17 +83,17 @@ export default class User extends BaseModel {
   }
 
   public static async findUserByToken(token: string, lean = true) {
-    const user = await UserModel.findOne({ token }).select('uid token serverType auth').lean(lean);
+    const user: UserType = await UserModel.findOne({ token }).select('uid token serverType auth').lean(lean);
     return user;
   }
 
   public static async findUserByTel(tel: string, lean = true) {
-    const user = await UserModel.findOne({ tel }).select('uid tel').lean(lean);
+    const user: UserType = await UserModel.findOne({ tel }).select('uid tel').lean(lean);
     return user;
   }
 
   public static async findUserByUid(uid: number, lean = true) {
-    const user = await UserModel.findOne({ uid }).select('uid tel').lean(lean);
+    const user: UserType = await UserModel.findOne({ uid }).select('uid tel').lean(lean);
     return user;
   }
 
@@ -105,9 +105,11 @@ export default class User extends BaseModel {
         $in: value
       };
     }
-    const user = await UserModel.find(searchObj).select('uid tel username').lean(lean);
+    const user: UserType[] = await UserModel.find(searchObj).select('uid tel username').lean(lean);
     return user;
   }
 }
 
 export const UserModel = getModelForClass(User);
+
+export interface UserType extends Pick<DocumentType<User>, keyof User>{};
diff --git a/shared/db/generalField.ts b/shared/db/generalField.ts
new file mode 100644
index 000000000..d0eac01b6
--- /dev/null
+++ b/shared/db/generalField.ts
@@ -0,0 +1,43 @@
+import { prop } from '@typegoose/typegoose';
+
+export class CeAttrData {
+    @prop({ required: true })
+    base?: number = 0;
+    @prop({ required: true })
+    ratioUp: number = 0;
+    @prop({ required: true })
+    fixUp: number = 0;
+}
+
+export class CeAttr {
+  @prop({ required: false })
+  hp?: CeAttrData;
+  @prop({ required: false })
+  atk?: CeAttrData;
+  @prop({ required: false })
+  matk?: CeAttrData;
+  @prop({ required: false })
+  def?: CeAttrData;
+  @prop({ required: false })
+  mdef?: CeAttrData;
+  @prop({ required: false })
+  agi?: CeAttrData;
+  @prop({ required: false })
+  luk?: CeAttrData;
+  @prop({ required: false })
+  hit?: CeAttrData;
+  @prop({ required: false })
+  cri?: CeAttrData;
+  @prop({ required: false })
+  flee?: CeAttrData;
+  @prop({ required: false })
+  antCri?: CeAttrData;
+  @prop({ required: false })
+  damageIncrease?: CeAttrData;
+  @prop({ required: false })
+  damageDecrease?: CeAttrData;
+  @prop({ required: false })
+  defIngnore?: CeAttrData;
+  @prop({ required: false })
+  bloodSuck?: CeAttrData;
+}
\ No newline at end of file
diff --git a/shared/pubUtils/dictionary/DicFriendShipLevel.ts b/shared/pubUtils/dictionary/DicFriendShipLevel.ts
index c7f2cca55..1744d5800 100644
--- a/shared/pubUtils/dictionary/DicFriendShipLevel.ts
+++ b/shared/pubUtils/dictionary/DicFriendShipLevel.ts
@@ -11,7 +11,7 @@ export interface DicFriendShipLevel {
     readonly add: number;
 }
 
-const str = readJsonFile(FILENAME.DIC_FRIEND_SHIP);
+const str = readJsonFile(FILENAME.DIC_FRIEND_SHIP_LEVEL);
 let arr = JSON.parse(str);
 
 export const dicFriendShipLevel = new Array<DicFriendShipLevel>();
diff --git a/shared/pubUtils/gamedata.ts b/shared/pubUtils/gamedata.ts
index 995ab82f8..e9be304d8 100644
--- a/shared/pubUtils/gamedata.ts
+++ b/shared/pubUtils/gamedata.ts
@@ -321,7 +321,7 @@ function parseFiendShipLevelMaps() {
     const file = 'dic_zyz_friend_ship_level';
     const data = gamedata['jsons'][file] || [];
     data.forEach(elem => {
-        if (elem && elem.id) {
+        if (elem && elem.level) {
             fiendShipLevelMaps.set(elem.level, elem);
         }
     });
diff --git a/web-server/tsconfig.json b/web-server/tsconfig.json
index 32654dbbf..ba55305c2 100644
--- a/web-server/tsconfig.json
+++ b/web-server/tsconfig.json
@@ -19,6 +19,7 @@
     "noFallthroughCasesInSwitch": true,
     "skipLibCheck": true,
     "skipDefaultLibCheck": true,
+    "strictNullChecks": false,
     "inlineSourceMap": true,
     "importHelpers": true,
     "baseUrl": ".",