namespace * Byway.Thrift.Data.Net

enum ACTIVITY_TYPE {
	DefaultType = 0
	ActTypeMining = 1
	ActTypeGuessColor = 2
	ActTypeRace = 3
	ActTypeDiscountGift = 4
	ActTypeAddGift = 5
	ActTypeSuperGift = 6
	ActTypeCatnip = 7
	ActTypePass = 8
}


struct ActLog {
	1: i32 Type,
	2: i64 Time,
	3: string Param,
}


enum ActLogType {
	None = 0
	FirstLogin = 1
	CompleteRestroom = 2
	CompleteRestaurant = 3
	CompleteBathroom = 4
	CompleteCloakroom = 5
	GetNewAvatar = 6
	GetNewAvatarFrame = 7
	GetNewEmotion = 8
	GetNewDecoration = 9
	GetNewCostume = 10
	CompleteCardAlbum = 11
	CompleteAllCards = 12
	GetChampionshipRank = 13
	GetChampionshipPrize = 14
	GetLimitedActivityPrize = 15
	JoinFriendCoopActivity = 16
	GetVisitGamePrize = 17
	GetVisitGamePrize1 = 18
	OpenPetTreasure = 19
	VisitUpvote = 20
	CompleteHandbookAchievement = 21
	CompleteChapterScenes = 22
	LostUserReturn = 23
}


struct ActivityCfg {
	1: i32 Id,
	2: i32 Type,
	3: i64 Starttime,
	4: i64 Endtime,
	5: i32 Level,
	6: string Title,
	7: string MailTitle,
	8: string MailContent,
	9: string RewardItem,
	10: string Extra,
}


struct ActivityInfo {
	1: i32 Id,
	2: i32 Type,
	3: i32 StartTime,
	4: i32 EndTime,
	5: i32 Status,
	6: string Title,
	7: i32 Red,
}


struct ActivityNotify {
	1: ActivityInfo Info,
}


struct AdItem {
	1: i32 Watch,
	2: i32 LastWatch,
	3: i32 ItemId,
}


struct AdminReq {
	1: string Func,
	2: binary Info,
}


struct AdminRes {
	1: string Func,
	2: string Info,
}


struct AvatarInfo {
	1: i32 Id,
	2: i64 EndTime,
	3: i64 AddTime,
}


struct BaseInfo {
	1: i32 EnergyMul,
	2: bool IsFirstBuy,
	3: i32 EnergyBuy,
	4: i32 EnergyAD,
	5: LANG_TYPE Lang,
}


enum CHESS_EX_TYPE {
	ChessExNone = 0
	ChessExBubble = 1
	ChessExBox = 2
	ChessExQuickBuy = 3
	ChessExEvent = 4
	ChessExEventLittleApprentice = 5
	ChessExEmitRollback = 6
}


struct Card {
	1: i32 Id,
	2: i32 Count,
}


struct CardPack {
	1: i32 Id,
	2: list<i32> Card,
}


struct CatReturnGiftCfg {
	1: i32 Skin,
	2: i32 Prob,
	3: list<CatReturnGiftCfgReward> RewardList,
	4: i32 ClearTime,
}


struct CatReturnGiftCfgReward {
	1: i32 Id,
	2: i32 Score,
	3: list<ItemInfo> Reward,
	4: i32 Total,
	5: i32 StarReward,
}


struct CatnipGame {
	1: i32 Id,
	2: i32 Status,
	3: i32 Progress,
	4: list<i32> Reward,
	5: ResPlayerSimple Partner,
	6: i32 Emoji,
	7: i32 SendEmoji,
	8: i32 FriendProgress,
}


struct CatnipInvite {
	1: i64 Uid,
	2: i64 Time,
	3: i32 Type,
	4: ResPlayerSimple Player,
}


struct ChampionshipCfg {
	1: i32 Id,
	2: i32 Skin,
	3: list<ChampionshipCfgJackpot> JackpotList,
	4: list<ChampionshipCfgRank> RankList,
	5: i32 ClearTime,
	6: string Title,
}


struct ChampionshipCfgJackpot {
	1: i32 Id,
	2: i32 Score,
	3: i32 Total,
	4: list<ItemInfo> Items,
	5: i32 StarReward,
}


struct ChampionshipCfgRank {
	1: i32 Id,
	2: i32 Min,
	3: i32 Max,
	4: list<ItemInfo> Items,
}


struct ChessBag {
	1: list<ChessBagGrid> ChessBagGrids,
	2: i32 ChessBuyCnt,
	3: i32 ChessFreeCnt,
}


struct ChessBagGrid {
	1: i32 Id,
	2: i32 ChessId,
	3: i32 EmitId,
}


struct ChessHandle {
	1: HANDLE_TYPE type,
	2: i32 Emit,
	3: i32 ChessId,
	4: i32 Id,
	5: list<i32> ActType,
}


struct ChipInfo {
	1: i64 Uid,
	2: i32 EmojiId,
}


struct ClientReq {
	1: string func,
	2: string cid,
	3: binary info,
	4: string sessionId,
	5: string gatewayId,
	6: string userId,
	7: string userBase,
}


struct ClientRes {
	1: string func,
	2: string cid,
	3: binary info,
}


struct CollectItem {
	1: i32 Id,
	2: list<ItemInfo> Items,
}


struct DailyTask {
	1: i32 Status,
	2: bool UnLock,
	3: QuestProgress Progress,
	4: list<ItemInfo> Items,
	5: i32 Id,
	6: i32 Index,
}


struct DailyWeek {
	1: list<ItemInfo> Items,
	2: bool Status,
	3: i32 NeedActive,
}


struct DecoratePart {
	1: i32 Id,
	2: list<ItemInfo> Items,
}


struct EmojiInfo {
	1: i32 Id,
	2: i64 EndTime,
	3: i64 AddTime,
}


enum FRIEND_REPLY_HANDLE_ERR_TYPE {
	None = 0
	Catnip = 1
}


enum FRIEND_REPLY_TYPE {
	None = 0
	Greet = 1
	ReturnGreet = 2
	ReplyTypeCatnip = 3
	ReplyTypeCatnipItems = 4
}


struct FaceInfo {
	1: i32 Id,
	2: i64 EndTime,
	3: i64 AddTime,
}


struct ForceKickOut {
}


struct FriendBubbleInfo {
	1: i32 Id,
	2: i32 Type,
	3: list<ItemInfo> Items,
	4: i64 Uid,
}


struct FriendRoom {
	1: i64 Uid,
	2: string Name,
	3: i32 Face,
	4: i32 Avatar,
	5: i32 Times,
}


struct GuessColorInfo {
	1: map<i32, i32> Map
}


struct GuideTask {
	1: i32 Status,
	2: QuestProgress Progress,
	3: i32 Id,
}


enum HANDLE_TYPE {
	Add = 0
	Compose = 1
	Buy = 2
	Sell = 3
	Remove = 4
	Order_Remove = 5
	Add_From_Buffer = 6
	Remove_To_Bag = 7
	Add_From_Bag = 8
	Separate_Add = 9
	Separate_Remove = 10
	Upgrade_Add = 11
	Upgrade_Remove = 12
	Exchange_Add = 13
	Exchange_Remove = 14
	Open_Chest = 15
	Lucky_Cat = 16
	Chest_Shop = 17
}


struct Handbook {
	1: list<HandbookInfo> Handbooks,
	2: list<string> Collect,
}


struct HandbookInfo {
	1: i32 ChessId,
	2: i32 Status,
}


enum ITEM_POP_LABEL {
	Playroom = 0
	PiggyBank = 1
	Charge = 2
	Endless = 3
	LevUpReward = 4
	HandleChess = 5
	HandbookReward = 6
	OrderReward = 7
	DecorateCost = 8
	DecorateAdd = 9
	BuyChessBagGrid = 10
	ChessEx = 11
	CardCollectReward = 12
	ExStarReward = 13
	AllCollectReward = 14
	GuideReward = 15
	DailyTaskReward = 16
	DailyWeekReward = 17
	BuyEnergy = 18
	SevenLoginRewardLabel = 19
	MonthLoginReward = 20
	FastProduceReward = 21
	LimitSenceReward = 22
	MailReward = 23
	FreeShop = 24
	ChessShop = 25
	RefreshChessShop = 26
	EndlessReward = 27
	PiggyBankReward = 28
	ChampshipReward = 29
	LimitEventReward = 30
	ChampshipRankReward = 31
	invite = 32
	SelectLimitEvent = 33
	MiningTake = 34
	MiningReward = 35
	GuessColor = 36
	GuessColorReward = 37
	RaceReward = 38
	PlayroomGame = 39
	PlayroomDraw = 40
	PlayroomChip = 41
	PlayroomFlip = 42
	FriendtreasureFilp = 43
	FriendtreasureEnd = 44
	Gm = 45
	Friendtreasure = 46
	CardHandbookReward = 47
	LimitEventChestRain = 48
	GetEnergyByAD = 49
	SourceChest = 50
	PlayroomBuyItem = 51
	CardSeasonFirstReward = 52
	AllCollectRewardHB = 53
	PlayroomShop = 54
	HandbookAllReward = 55
	TLUpvote = 56
	Collect = 57
	ActivityGift = 58
	ActivityReward = 59
	CatTrickReward = 60
	AddWish = 61
	GetWish = 62
	PlayroomTask = 63
	PlayroomTaskReward = 64
	PlayroomUpvote = 65
	DecorateReward = 66
	CatnipReward = 67
	CatnipGrandReward = 68
	CatnipPlay = 69
	FriendTReward = 70
	PetTheif = 71
	GuideTaskReward = 72
	GuideActiveReward = 73
	PassCharge = 74
	ActPassReward = 75
	FriendReplyHandle = 76
	GetChessRetireReward = 77
	ApplyFriendSponsor = 78
	PetFurShop = 79
	ActTypeAddGift = 80
	CatReturnGiftReward = 81
	PLevUpReward = 82 
	StrokingKitten = 83
	MiniGame = 84
}


enum ITEM_TYPE {
	Energy = 0
	Star = 1
	Diamond = 2
}


struct ItemInfo {
	1: i32 Id,
	2: i32 Num,
}


struct ItemList {
	1: list<ItemInfo> List,
}


struct ItemNotify {
	1: map<i32, i32> Item
}


enum LANG_TYPE {
	LangCn = 0
	LangEn = 1
	LangPtbr = 2
	LangEsLatam = 3
}


enum LOGIN_TYPE {
	AccountLogin = 0
	CodeLogin = 1
	DeviceLogin = 2
	SdkLogin = 3
}


struct LimitEvent {
	1: i32 EndTime,
	2: i32 Cd,
	3: double mul,
	4: i32 StartTime,
	5: map<string, i32> Param
	6: i32 ShowTime,
}


struct LimitEventNotify {
	1: i32 Id,
	2: i32 Type,
	3: i32 EndTime,
	4: i32 Cd,
}


enum LimitEventParam {
	LepNone = 0
	CatTrickEnergy = 1
	CatTrickType = 2
	PaybackDayCount = 3
	LuckyCatEarnings = 4
	SenceDashTimes = 5
}


struct LogoutPetWork {
	1: i64 WorkTime,
	2: i64 RemainTime,
}


struct MailInfo {
	1: i32 Id,
	2: string Title,
	3: string Content,
	4: i32 Time,
	5: i32 Status,
	6: list<ItemInfo> Items,
	7: i32 Type,
	8: string TitleEn,
	9: string ContentEn,
	10: string SubTitle,
	11: string SubTitleEn,
	12: string TitlePtBr,
	13: string ContentPtBr,
	14: string SubTitlePtBr,
	15: string TitleEsLa,
	16: string SubTitleEsLa,
	17: string ContentEsLa,
}


struct MailNotify {
	1: MailInfo Info,
}


struct MinigCfgGem {
	1: string Area,
}


struct MiningCfg {
	1: string Name,
	2: i32 PassNum,
	3: list<ItemInfo> itemCost,
	4: i32 ItemId,
	5: i32 startItemnum,
	6: map<string, MinigCfgGem> Gem
	7: map<string, MiningCfgJackpot> Jackpot
	8: map<string, MiningCfgPass> Pass
}


struct MiningCfgJackpot {
	1: i32 Prob,
	2: list<ItemInfo> Items,
}


struct MiningCfgPass {
	1: list<ItemInfo> Items,
	2: string Area,
	3: i32 Gem,
	4: i32 StarReward,
}


struct NofiPlayroomStatus {
	1: i32 WorkOutline,
}


struct NotifyActRed {
	1: i32 Id,
	2: i32 Red,
}


struct NotifyAddEnergy {
	1: i64 dwUin,
	2: i32 addCnt,
}


struct NotifyFriendCard {
	1: ResFriendCard Info,
}


struct NotifyFriendLog {
	1: ResFriendLog info,
	2: FriendBubbleInfo Bubble,
}


struct NotifyInvitedSuccess {
	1: i32 ResultCode,
	2: list<i32> IdLists,
}


struct NotifyPlayroomBroken {
	1: ResPlayerSimple Player,
}


struct NotifyPlayroomKiss {
	1: i32 Kiss,
}


struct NotifyPlayroomLose {
	1: list<ItemInfo> LoseItem,
	2: list<ChipInfo> Chip,
	3: i64 Revenge,
}


struct NotifyPlayroomMood {
	1: i32 AllMood,
	2: map<i32, i32> Mood
	3: map<i32, i32> Physiology
	4: list<AdItem> AdItem,
}


struct NotifyPlayroomTask {
	1: list<DailyTask> DailyTask,
	2: list<i32> DailyTaskReward,
}


struct NotifyPlayroomWork {
	1: i32 StartTime,
	2: i32 WorkStatus,
}


struct NotifyRenewBuyEnergyCnt {
	1: i64 dwUin,
	2: i32 CurCnt,
}


enum ORDER_TYPE {
	Default = 0
	CommonType = 1
	ExtraType = 2
	SuperType = 3
	PreheatType = 4
	TriggerType = 5
	CleanType = 6
	CleanOrderType = 7
	CleanType2 = 8
	ComfortType = 9
	GuideType = 10
	PetType = 11
	PreviewType = 12
	FixedType = 13
	PlayroomType = 14
}


struct Order {
	1: i32 Id,
	2: list<i32> ChessId,
	3: i32 type,
	4: list<ItemInfo> Items,
}


struct PartBag {
	1: list<PartBagGrid> PartBagGrids,
}


struct PartBagGrid {
	1: i32 PartId,
	2: i32 Count,
}


struct PlayroomAirInfo {
	1: i32 Id,
	2: i64 EndTime,
	3: i64 AddTime,
	4: string Label,
}


struct PlayroomCollectInfo {
	1: i32 Id,
	2: i64 EndTime,
	3: i64 AddTime,
	4: string Label,
}


struct PlayroomDress {
	1: list<PlayroomDressInfo> List,
}


struct PlayroomDressInfo {
	1: i32 Id,
	2: i64 EndTime,
	3: i64 AddTime,
	4: string Label,
}


struct QuestProgress {
	1: string Label,
	2: i32 Num,
	3: i32 Target,
	4: bool Status,
	5: i32 Param,
}


enum RES_CODE {
	Fail = 0
	Success = 1
	ProtocolErrorAccountExist = 100
	ProtocolErrorAccountOrPwdError = 101
	ProtocolErrorAccountOrPwdShort = 102
	ProtocolErrorAccountFail = 103
	ProtocolErrorAccountNoExsit = 104
	ProtocolErrorAccountCodeError = 105
	ProtocolErrorAccountDeviceError = 106
	ProtocolErrorIdNotVerify = 107
	ProtocolErrorIdVerifyError = 108
}


struct RegHandbookAllReward {
	1: string Type,
}


struct ReqActPass {
}


struct ReqActPassReward {
}


struct ReqActivityCfgReload {
	1: list<ActivityCfg> List,
}


struct ReqActivityReward {
	1: i32 Id,
}


struct ReqAdWatch {
	1: i32 Type,
}


struct ReqAddGiftReward {
}


struct ReqAddNpc {
	1: i32 NpcId,
}


struct ReqAddWish {
	1: i32 Id,
	2: i32 Type,
}


struct ReqAdminBan {
	1: i64 Uid,
	2: i64 Time,
	3: string Reason,
}


struct ReqAdminGm {
	1: i64 Uid,
	2: string Command,
}


struct ReqAdminInfo {
	1: i64 Uid,
}


struct ReqAdminShipping {
	1: string OrderSn,
	2: i32 Status,
	3: string ChannelOrderSn,
}


struct ReqAgreeCardExchange {
	1: string Id,
}


struct ReqAgreeCardGive {
	1: string Id,
}


struct ReqAgreeFriend {
	1: i64 Uid,
}


struct ReqAllCollectReward {
}


struct ReqApplyFriend {
	1: i64 Uid,
	2: i32 Type,
}


struct ReqAreaReward {
	1: i32 AreaId,
}


struct ReqAutoAddInviteFriend {
	1: i64 id,
}


struct ReqAutoAddInviteFriend2 {
	1: string id,
}


struct ReqBindFacebookAccount {
	1: i64 dwUin,
	2: string BindAccountId,
}


struct ReqBuyChessBagGrid {
}


struct ReqBuyChessShop {
	1: i32 Id,
}


struct ReqBuyChessShop2 {
	1: i32 Id,
	2: map<string, i32> MChessData
}


struct ReqBuyEnergy {
	1: i32 Energy,
}


struct ReqCardCollectReward {
	1: i32 Color,
}


struct ReqCardExchange {
	1: i64 Uid,
	2: i32 CardId,
	3: i32 Emoji,
}


struct ReqCardGive {
	1: list<i64> Uid,
	2: i32 CardId,
}


struct ReqCardHandbookReward {
	1: i32 CardId,
}


struct ReqCardInfo {
}


struct ReqCardSeasonFirstReward {
}


struct ReqCardSend {
	1: i64 Uid,
	2: i32 CardId,
	3: i32 Emoji,
}


struct ReqCatReturnGift {
}


struct ReqCatReturnGiftReward {
}


struct ReqCatReturnGiftRewardGift {
	1: i32 Id,
}


struct ReqCatReturnGiftScore {
	1: i32 Score,
}


struct ReqCatTrickReward {
}


struct ReqCatnip {
}


struct ReqCatnipAgree {
	1: i32 Id,
	2: i64 Uid,
}


struct ReqCatnipEmoji {
	1: i32 Id,
	2: i32 EmojiId,
}


struct ReqCatnipGrandReward {
}


struct ReqCatnipInvite {
	1: i32 Id,
	2: i64 Uid,
}


struct ReqCatnipMultiply {
	1: i32 Multiply,
}


struct ReqCatnipPlay {
	1: i32 Id,
}


struct ReqCatnipRefuse {
	1: i32 Id,
	2: i64 Uid,
}


struct ReqCatnipReward {
	1: i32 Id,
}


struct ReqChampship {
}


struct ReqChampshipPreRank {
}


struct ReqChampshipRank {
}


struct ReqChampshipRankReward {
}


struct ReqChampshipReward {
}


struct ReqChangePassword {
	1: string UserName,
	2: string OldPwd,
	3: string NewPwd,
}


struct ReqChargeReceive {
	1: i64 Uid,
	2: string Content,
}


struct ReqChessEx {
	1: i32 OldChessId,
	2: i32 NewChessId,
	3: i32 CostDia,
	4: CHESS_EX_TYPE Type,
	5: map<string, i32> MChessData
	6: i32 CostStar,
}


struct ReqCollect {
	1: i32 Id,
}


struct ReqCollectInfo {
}


struct ReqCreateOrderSn {
	1: i32 ChargeId,
	2: string PlatForm,
	3: string channel,
	4: i32 Type,
	5: i64 Uid,
}


struct ReqCreatePetOrder {
}


struct ReqDailyUnlock {
}


struct ReqDecorate {
	1: i32 AreaId,
	2: i32 DecorateId,
}


struct ReqDecorateAll {
}


struct ReqDelFriend {
	1: i64 Uid,
}


struct ReqDelOrder {
	1: i32 OrderId,
}


struct ReqDeleteMail {
	1: i32 Id,
}


struct ReqEndless {
}


struct ReqEndlessReward {
}


struct ReqExStarReward {
	1: i32 Id,
}


struct ReqFastProduceInfo {
}


struct ReqFastProduceReward {
	1: i32 Energy,
}


struct ReqFreeShop {
}


struct ReqFriendApply {
	1: i32 Type,
}


struct ReqFriendByCode {
	1: string Code,
}


struct ReqFriendCardMsg {
}


struct ReqFriendIgnore {
	1: i64 Uid,
}


struct ReqFriendList {
}


struct ReqFriendPlayerSimple {
	1: i64 Uid,
}


struct ReqFriendRecommend {
}


struct ReqFriendReplyHandle {
	1: i32 LogId,
	2: string Param,
	3: i32 Type,
}


struct ReqFriendTLUpvote {
	1: i32 Id,
}


struct ReqFriendTReward {
	1: i32 Id,
}


struct ReqFriendTimeLine {
}


struct ReqFriendTreasure {
}


struct ReqFriendTreasureEnd {
}


struct ReqFriendTreasureFilp {
	1: i32 Pos,
}


struct ReqFriendTreasureStart {
	1: list<TreasureInfo> List,
	2: list<i32> List2,
}


struct ReqFurSet {
	1: i32 FurId,
}


struct ReqGetChessFromBuff {
	1: i32 ChessId,
	2: map<string, i32> MChessData
}


struct ReqGetChessRetireReward {
	1: string Id,
}


struct ReqGetDailyTaskReward {
	1: i32 Id,
}


struct ReqGetDailyWeekReward {
	1: i32 Id,
}


struct ReqGetEnergyByAD {
}


struct ReqGetFriendCard {
	1: string Id,
}


struct ReqGetGoldCard {
}


struct ReqGetGuideActiveReward {
	1: i32 Id,
}


struct ReqGetGuideTaskReward {
	1: i32 Id,
}


struct ReqGetHandbookReward {
	1: i32 ChessId,
}


struct ReqGetInviteReward {
	1: i32 GetIndex,
}


struct ReqGetMailReward {
	1: i32 Id,
}


struct ReqGetMonthLoginReward {
	1: i32 Id,
}


struct ReqGetSevenLoginReward {
	1: i32 Id,
}


struct ReqGetWish {
}


struct ReqGmCommand {
	1: string Command,
	2: string args,
}


struct ReqGuessColor {
}


struct ReqGuessColorReward {
}


struct ReqGuessColorTake {
	1: GuessColorInfo Map,
	2: map<i32, i32> OMap
}


struct ReqGuidePlayroom {
	1: i32 Id,
}


struct ReqGuideReward {
	1: i32 Id,
}


struct ReqId2Verify {
	1: string Id,
	2: string Name,
}


struct ReqInviteFriendData {
	1: i64 dwUin,
}


struct ReqKafkaLog {
	1: string Event,
	2: string Data,
}


struct ReqKv {
	1: i32 key,
	2: string value,
}


struct ReqLang {
	1: LANG_TYPE Lang,
}


struct ReqLimitEvent {
}


struct ReqLimitEventLuckyCat {
	1: i32 ChessId,
	2: map<string, i32> MChessData
}


struct ReqLimitEventReward {
	1: i32 Id,
}


struct ReqLimitSenceReward {
}


struct ReqLogin {
	1: string UserName,
	2: string UserPwd,
	3: string Code,
	4: string Device,
	5: LOGIN_TYPE type,
}


struct ReqLoginCode {
	1: string TelPhone,
}


struct ReqMailList {
}


struct ReqMasterCard {
	1: i32 Id,
	2: i32 CardId,
}


struct ReqMining {
}


struct ReqMiningReward {
}


struct ReqMiningTake {
	1: map<i32, string> Map
	2: i32 Gem,
}


struct ReqOfflineReconnect {
	1: i64 dwUin,
}


struct ReqOnlyBindFacebook {
	1: i64 dwUin,
	2: string BindAccountId,
}


struct ReqOrderShipping {
	1: string OrderSn,
	2: i32 Status,
	3: string ChannelOrderSn,
}


struct ReqPetFur {
}


struct ReqPetFurBuy {
	1: i32 FurId,
}


struct ReqPiggyBankReward {
}


struct ReqPlayerAsset {
}


struct ReqPlayerBaseInfo {
	1: i64 dwUin,
}


struct ReqPlayerBriefProfileData {
	1: i64 dwUin,
}


struct ReqPlayerChessData {
	1: i64 dwUin,
}


struct ReqPlayerProfileData {
	1: i64 dwUin,
}


struct ReqPlayroom {
}


struct ReqPlayroomBuyItem {
	1: i32 Id,
}


struct ReqPlayroomChip {
	1: list<i64> Uid,
}


struct ReqPlayroomDraw {
}


struct ReqPlayroomDressSet {
	1: map<i32, i32> DressSet
}


struct ReqPlayroomFlip {
	1: i32 Id,
}


struct ReqPlayroomFlipReward {
	1: i32 EmojiId,
}


struct ReqPlayroomGame {
	1: i32 Type,
	2: i32 EmojiId,
}


struct ReqPlayroomGameShowReward {
	1: i32 Type,
	2: i32 SelectId,
}


struct ReqPlayroomGuide {
	1: i32 Type,
}


struct ReqPlayroomInfo {
	1: i64 Uid,
}


struct ReqPlayroomInteract {
	1: i32 Id,
	2: i32 Type,
}


struct ReqPlayroomLose {
}


struct ReqPlayroomOutline {
	1: i32 OldChessId,
	2: i32 NewChessId,
	3: i32 CostDia,
	4: i32 Type,
	5: map<string, i32> MChessData
}


struct ReqPlayroomPetAirSet {
	1: i32 PetAirSet,
}


struct ReqPlayroomRest {
}


struct ReqPlayroomSelectReward {
	1: i32 Id,
	2: i32 EmojiId,
	3: i32 Type,
}


struct ReqPlayroomSetRoom {
	1: map<i32, i32> Playroom
}


struct ReqPlayroomShop {
	1: i32 Id,
	2: i32 Num,
}


struct ReqPlayroomTask {
	1: i32 Id,
}


struct ReqPlayroomTaskReward {
	1: i32 Type,
}


struct ReqPlayroomUnlock {
	1: i32 Id,
}


struct ReqPlayroomUpvote {
	1: i64 Id,
}


struct ReqPlayroomWork {
}


struct ReqPlayroomWorkOutline {
}


struct ReqPutChessInBag {
	1: i32 ChessId,
	2: i32 BagId,
	3: i32 EmitId,
	4: map<string, i32> MChessData
}


struct ReqPutPartInBag {
	1: i32 ChessId,
	2: map<string, i32> MChessData
}


struct ReqRace {
}


struct ReqRaceReward {
}


struct ReqRaceStart {
}


struct ReqRank {
	1: i32 Type,
}


struct ReqReadMail {
	1: i32 Id,
}


struct ReqRefreshChessShop {
}


struct ReqRefuseCardExchange {
	1: string Id,
}


struct ReqRefuseCardGive {
	1: string Id,
}


struct ReqRefuseCardSelect {
	1: string Id,
}


struct ReqRefuseFriend {
	1: i64 Uid,
}


struct ReqRegisterAccount {
	1: string UserName,
	2: string UserPwd,
	3: i32 dwUin,
	4: string Device,
}


struct ReqReload {
}


struct ReqReloadServerMail {
}


struct ReqRemoveAd {
	1: i64 dwUin,
}


struct ReqRewardOrder {
	1: i32 OrderId,
	2: map<string, i32> MChessData
	3: list<i32> ActType,
}


struct ReqSearchPlayer {
	1: string Uid,
}


struct ReqSelectCardExchange {
	1: string Id,
	2: i32 CardId,
}


struct ReqSelectLimitEvent {
	1: i32 Id,
}


struct ReqSelfInvited {
	1: i64 InviterId,
}


struct ReqSellChessNum {
	1: i32 ChessId,
}


struct ReqSendWishBeg {
	1: list<i64> Uid,
}


struct ReqSeparateChess {
	1: i32 ChessId,
	2: map<string, i32> MChessData
}


struct ReqServerInfo {
}


struct ReqServerTime {
	1: i64 dwUin,
}


struct ReqSetAvatar {
	1: i32 Avatar,
}


struct ReqSetEmoji {
	1: i32 Id,
	2: i32 Type,
}


struct ReqSetEnergyMul {
	1: i32 EnergyMul,
}


struct ReqSetFace {
	1: i32 Face,
}


struct ReqSetFacebookUrl {
	1: string Url,
}


struct ReqSetName {
	1: string Name,
}


struct ReqSetPetName {
	1: string Name,
}


struct ReqShippingOrder {
	1: string OrderSn,
	2: string ProduceId,
	3: string Token,
	4: i32 Status,
}


struct ReqSourceChest {
	1: i32 ChestId,
	2: map<string, i32> MChessData
}


struct ReqSynGameData {
	1: i64 dwUin,
	2: string NewFBId,
}


struct ReqTakeChessOutBag {
	1: i32 BagId,
	2: map<string, i32> MChessData
}


struct ReqTakeChessOutBagToHonor {
	1: i32 BagId,
}


struct ReqUnBindFacebook {
	1: i64 dwUin,
	2: string BindAccountId,
}


struct ReqUpgradeChess {
	1: i32 ChessId,
	2: map<string, i32> MChessData
}


struct ReqUserInfo {
}


struct ReqWishApply {
	1: i64 Uid,
}


struct ReqWishApplyList {
}


struct ResActPass {
	1: i32 Id,
	2: i32 Status,
	3: i32 EndTime,
	4: i32 Template,
	6: i32 Score,
	7: list<i32> Reward,
	8: bool LowPass,
	9: bool HighPass,
}


struct ResActPassReward {
	1: RES_CODE Code,
	2: string Msg,
	3: list<i32> RewardLevel,
}


struct ResActRed {
	1: map<i32, i32> Red
}


struct ResActivity {
	1: list<ActivityInfo> ActiveList,
	2: i64 AddEnd,
	3: bool AddReward,
}


struct ResActivityCfgReload {
	1: i32 Code,
	2: string Msg,
}


struct ResActivityReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResAdWatch {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResAddGiftReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResAddNpc {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 NpcId,
}


struct ResAddWish {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResAgreeCardExchange {
	1: RES_CODE Code,
	2: string Msg,
	3: string Id,
	4: i32 Emoji,
}


struct ResAgreeCardGive {
	1: RES_CODE Code,
	2: string Msg,
	3: string Id,
}


struct ResAgreeFriend {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
	4: ResPlayerSimple Player,
}


struct ResAllCollectReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResApplyFriend {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
}


struct ResAreaReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResAutoAddInviteFriend {
	1: i32 ResultCode,
}


struct ResAutoAddInviteFriend2 {
	1: i32 ResultCode,
}


struct ResAvatarInfo {
	1: list<AvatarInfo> AvatarList,
	2: i32 SetId,
}


struct ResBindFacebookAccount {
	1: i64 dwUin,
	2: string BindAccountId,
	3: i32 ResultCode,
}


struct ResBuyChessBagGrid {
	1: RES_CODE code,
	2: string msg,
}


struct ResBuyChessShop {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResBuyChessShop2 {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResBuyEnergy {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCardCollectReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCardExchange {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCardGive {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCardHandbookReward {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 CardId,
}


struct ResCardInfo {
	1: list<Card> CardList,
	2: i32 ExStar,
	3: i32 Status,
	4: list<i32> CollectId,
	5: i32 ExTimes,
	6: i32 ReqTimes,
	7: map<i32, i32> AllCard
	8: i32 EndTime,
	9: list<i64> ReqUid,
	10: list<i64> ExUid,
	11: i32 GoldTimes,
	12: i32 Round,
	13: map<i32, i32> Handbook
	14: bool SeasonFirst,
}


struct ResCardSeasonFirstReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCardSend {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCatReturnGift {
	1: i32 Id,
	2: i64 StartTime,
	3: i64 EndTime,
	4: i32 Score,
	5: i32 Reward,
	6: CatReturnGiftCfg Cfg,
}


struct ResCatReturnGiftReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCatReturnGiftRewardGift {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCatReturnGiftScore {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCatTrickReward {
	1: RES_CODE Code,
	2: string Msg,
	3: bool IsClose,
}


struct ResCatnip {
	1: i32 Id,
	2: i32 Status,
	3: i32 EndTime,
	4: i32 Template,
	5: list<CatnipGame> GameList,
	6: i32 Multiply,
	7: list<CatnipInvite> FriendList,
}


struct ResCatnipAgree {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
}


struct ResCatnipEmoji {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 EmojiId,
	4: i32 Id,
}


struct ResCatnipGrandReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCatnipInvite {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
}


struct ResCatnipMultiply {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Multiply,
}


struct ResCatnipPlay {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResCatnipRefuse {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
}


struct ResCatnipReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResChampship {
	1: i32 Score,
	2: i32 Reward,
	3: i32 EndTime,
	4: i32 Period,
	5: i32 Rank,
	6: i32 RankReward,
	7: i32 Status,
	8: i32 TodayActivityId,
	9: i32 YesterdayActivityId,
	10: ChampionshipCfg Cfg,
	11: string Title,
	12: i32 StartTime,
}


struct ResChampshipPreRank {
	1: map<i32, ResPlayerRank> RankList
	2: i32 MyRank,
	3: double MyScore,
	4: ChampionshipCfg cfg;
}


struct ResChampshipRank {
	1: map<i32, ResPlayerRank> RankList
	2: i32 MyRank,
	3: double MyScore,
}


struct ResChampshipRankReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResChampshipReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResChangePassword {
	1: i32 ResultCode,
}


struct ResCharge {
	1: double Charge,
	2: i32 Total,
	3: list<i32> First,
	4: map<i32, ResSpecialShop> SpecialShop
	5: i32 FreeShop,
	6: map<i32, ResChessShop> ChessShop
	7: map<i32, i32> Gift
	8: bool Ad,
	9: WishList Wish,
	10: double SpecialCharge,
	11: i32 SpecialChargeWeek,
	12: double TodayCharge,
	13: double MonthCharge,
	14: i64 AdEndTime,
	15: map<i32, WeeklyDiscountInfo> WeeklyDiscount
	16: i64 PetWorkRemainTime,
	17: i64 WeeklyEndTime,
}


struct ResChargeReceive {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResChessColorData {
	1: map<string, i32> MChessColorData
}


struct ResChessEx {
	1: RES_CODE code,
	2: string msg,
}


struct ResChessRainReward {
	1: list<ItemInfo> Items,
	2: i32 Id,
}


struct ResChessShop {
	1: i32 Diamond,
	2: i32 Count,
	3: i32 ChessId,
}


struct ResCollect {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResCollectInfo {
	1: list<i32> Id,
	2: list<CollectItem> Items,
}


struct ResCreateOrderSn {
	1: string OrderSn,
}


struct ResDailyTask {
	1: map<i32, DailyWeek> WeekReward
	2: map<i32, DailyTask> DailyTask
	3: i32 Active,
	4: i32 DayEnd,
	5: i32 WeekEnd,
}


struct ResDailyUnlock {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResDecorate {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResDecorateAll {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResDecorateInfo {
	1: i32 AreaId,
	2: list<i32> mFinishList,
	3: list<i32> RewardArea,
	4: list<DecoratePart> Parts,
	5: list<DecoratePart> Stars,
}


struct ResDelFriend {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
}


struct ResDelOrder {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResDeleteMail {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResEndless {
	1: i32 Id,
	2: map<i32, ResEndlessInfo> EndlessList
}


struct ResEndlessInfo {
	1: i32 ChargeId,
	2: i32 Type,
	3: list<ItemInfo> Items,
}


struct ResEndlessReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResExStarReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResFaceInfo {
	1: list<FaceInfo> FaceList,
	2: i32 SetId,
}


struct ResFastProduceInfo {
	1: i32 Energy,
	2: i32 Num,
	3: i64 EndTime,
}


struct ResFastProduceReward {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 EndTime,
	4: i32 Num,
}


struct ResFreeShop {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResFriendApply {
	1: list<ResFriendApplyInfo> ApplyList,
}


struct ResFriendApplyInfo {
	1: ResPlayerSimple Player,
	2: i32 Time,
}


struct ResFriendApplyNotify {
	1: ResPlayerSimple Player,
	2: i32 Type,
	3: i32 Time,
}


struct ResFriendBubble {
	1: list<FriendBubbleInfo> Bubble,
}


struct ResFriendByCode {
	1: RES_CODE Code,
	2: string Msg,
	3: ResPlayerSimple Player,
}


struct ResFriendCard {
	1: i64 Uid,
	2: string Name,
	3: i32 Face,
	4: i32 Avatar,
	5: i32 Level,
	6: i32 Type,
	7: i32 Time,
	8: i32 CardId,
	9: i32 ExCardId,
	10: i32 Status,
	11: string Id,
	12: i32 Emoji,
}


struct ResFriendCardMsg {
	1: list<ResFriendCard> MsgList,
}


struct ResFriendIgnore {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResFriendList {
	1: list<ResPlayerSimple> FriendList,
	3: list<i64> ReqApplyList,
	2: list<i32> Npc,
	4: i32 Sponsor,
}


struct ResFriendLog {
	1: ResPlayerSimple Player,
	2: i32 Type,
	3: i32 Time,
	4: string Param,
	5: i32 Id,
	6: bool Upvote,
}


struct ResFriendPlayerSimple {
	1: i64 Uid,
	2: string Name,
	3: i32 Face,
	4: i32 Avatar,
	5: i32 Level,
	6: i32 Decorate,
	7: i32 login,
	8: i32 loginout,
	9: string Facebook,
	10: map<i32, i32> Emoji
	11: i64 AddTime,
	12: i64 Interact,
	13: map<i32, i32> Playroom
	14: map<i32, i32> DressSet
	15: list<i32> Friend,
	16: ActLog Last,
	17: map<i32, i32> Physiology
	18: string PetName,
	19: i32 PetFur,
}


struct ResFriendRecommend {
	1: list<ResPlayerSimple> List,
}


struct ResFriendReply {
	1: i32 Id,
	2: i32 Type,
	3: string Param,
	4: i32 Status,
	5: i64 AddTime,
	6: i64 EndTime,
	7: ResPlayerSimple Player,
	8: list<ItemInfo> Items,
}


struct ResFriendReplyHandle {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 LogId,
	4: i32 Type,
	5: FRIEND_REPLY_HANDLE_ERR_TYPE ErrType,
}


struct ResFriendReplyNotify {
	1: ResFriendReply info,
	2: i32 Type,
	3: i32 Time,
}


struct ResFriendTLUpvote {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResFriendTReward {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResFriendTimeLine {
	1: list<ResFriendLog> Log,
	2: list<ResFriendReply> Reply,
}


struct ResFriendTreasure {
	1: i32 Status,
	2: i32 Star,
	3: i32 Shift,
	4: list<TreasureInfo> List,
	5: list<i32> List2,
	6: list<i64> Uids,
}


struct ResFriendTreasureEnd {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResFriendTreasureFilp {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResFriendTreasureStar {
	1: i32 Star,
}


struct ResFriendTreasureStart {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResFurSet {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGetChessFromBuff {
	1: RES_CODE code,
	2: string msg,
}


struct ResGetChessRetireReward {
	1: RES_CODE code,
	2: string msg,
	3: string Id,
}


struct ResGetDailyTaskReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGetDailyWeekReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGetEnergyByAD {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGetFriendCard {
	1: RES_CODE Code,
	2: string Msg,
	3: string Id,
	4: i32 CardId,
	5: i32 Emoji,
}


struct ResGetGoldCard {
	1: i32 Four,
	2: i32 Five,
}


struct ResGetGuideActiveReward {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResGetGuideTaskReward {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResGetHandbookReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGetInviteReward {
	1: i32 ResultCode,
}


struct ResGetMailReward {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResGetMonthLoginReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGetSevenLoginReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGetWish {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGuessColor {
	1: i32 Id,
	2: i32 Status,
	3: i32 EndTime,
	4: i32 Template,
	5: i32 Pass,
	6: list<GuessColorInfo> MapList,
	7: map<i32, i32> OMap
	8: i32 WinTime,
	9: opponent Opponent,
}


struct ResGuessColorReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGuessColorTake {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGuideInfo {
	1: map<i32, i32> Reward
}


struct ResGuidePlayroom {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGuideReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResGuideTask {
	1: list<i32> ActiveReward,
	2: map<i32, GuideTask> Task
	3: i32 Active,
	4: i32 UnlockTime,
}


struct ResHandbookAllReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResId2Verify {
	1: RES_CODE ResultCode,
	2: string Msg,
}


struct ResInviteFriendData {
	1: list<i32> IdLists,
	2: i32 GetIndex,
}


struct ResItem {
	1: map<i32, i32> Item
}


struct ResItemPop {
	1: i32 Id,
	2: list<ItemInfo> Items,
	3: list<CardPack> CardPacks,
	4: string Lable,
}


struct ResKv {
	1: map<i32, string> Kv
}


struct ResLang {
	1: RES_CODE ResultCode,
	2: string Msg,
}


struct ResLimitEvent {
	1: map<i32, LimitEvent> LimitEventList
}


struct ResLimitEventLuckyCat {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResLimitEventProgress {
	1: i32 ProgressMax,
	2: i32 Progress,
	3: map<i32, i32> ProgressReward
}


struct ResLimitEventReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResLimitSenceReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResLogin {
	1: i32 ResultCode,
	2: i64 dwUin,
	3: string UserName,
	4: string FaceBookId,
	5: string Msg,
}


struct ResLoginCode {
	1: i32 ResultCode,
	2: string Msg,
	3: string Code,
}


struct ResMailList {
	1: map<i32, MailInfo> MailList
}


struct ResMasterCard {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 MasterId,
	4: i32 CardId,
}


struct ResMining {
	1: i32 Id,
	2: i32 Status,
	3: i32 EndTime,
	4: i32 Template,
	5: i32 Pass,
	6: list<i32> Gem,
	7: map<i32, string> Map
	8: i32 Mining,
	9: map<i32, ItemList> PassReward
}


struct ResMiningReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResMiningTake {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResNotifyCard {
	1: map<i32, i32> Card
	2: map<i32, i32> Master
	3: i32 ExStar,
	4: map<i32, i32> Handbook
}


struct ResNotifyCardTimes {
	1: i32 ExTimes,
	2: i32 ReqTimes,
	3: list<i64> ReqUid,
	4: list<i64> ExUid,
	5: i32 GoldTimes,
}


struct ResOfflineReconnect {
	1: i64 dwUin,
	2: i32 Result,
}


struct ResOnlyBindFacebook {
	1: i64 dwUin,
	2: string BindAccountId,
	3: i32 ResultCode,
}


struct ResOrderList {
	1: list<Order> OrderList,
}


struct ResOrderShipping {
	1: i32 Code,
	2: string Msg,
}


struct ResPetFur {
	1: list<i32> FurId,
	2: i32 FurSet,
	3: i32 FreeCount,
}


struct ResPetFurBuy {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPiggyBank {
	1: i32 Type,
	2: i32 Diamond,
	3: i32 Count,
	4: i32 EndTime,
}


struct ResPiggyBankReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayerAsset {
	1: i64 dwUin,
	2: i32 energy,
	3: i32 star,
	4: i32 recoverTime,
	5: i32 diamond,
	6: i32 level,
	7: i32 exp,
	8: i32 Login,
	9: i32 Logout,
	10: i32 PExp,
	11: i32 LoginDay,
	12: i32 PLevel,
}


struct ResPlayerBaseInfo {
	1: i64 dwUin,
	2: i32 energy,
	3: i32 star,
	4: i32 recoverTime,
	5: i32 diamond,
	6: i32 level,
	7: i32 exp,
	8: string startOrderId,
	9: i32 musicCode,
	10: i32 guild,
	11: i32 packUnlockCount,
	12: i32 lastPlayTime,
	13: i64 ban,
	14: string userName,
	15: i32 loginTime,
	16: i32 logoutTime,
	17: i32 node,
	18: i32 rolecreatetime,
	19: i32 EmitOrderCnt,
	20: i32 NoAd,
	21: i32 ChampshipsGroupID,
	22: i32 LastChampGroupID,
	23: string FaceBookId,
	24: i32 registerTime,
}


struct ResPlayerBriefProfileData {
	1: i64 dwUin,
	2: i32 ImageFrame,
	3: i32 ImageIcon,
	4: i32 DecorateCnt,
	5: string NickName,
	6: string PicURL,
	7: i32 ActiveTime,
	11: map<i32, i32> SetEmoji
}


struct ResPlayerChessData {
	1: i64 dwUin,
	2: map<string, i32> MChessData
	3: list<i32> ChessList,
	4: list<i32> ChessBuff,
}


struct ResPlayerChessInfo {
	1: list<i32> ChessList,
	2: list<i32> ChessBuff,
	3: ChessBag ChessBag,
	4: list<string> RetireEmit,
	5: list<i32> Honor,
	6: PartBag PartBag,
	7: list<string> RetireReward,
	8: map<string, RETIRE_STATUS> RetireData,
}

enum RETIRE_STATUS {
	EMIT_RETIRE_START = 1,
	EMIT_RETIRE_ING = 2,
	EMIT_RETIRE_END = 3,
}


struct ResPlayerLougouMsg {
	1: i32 Type,
	2: string Name,
	3: list<i32> Face,
	4: i32 Count,
	5: list<string> FacebookPic,
	6: list<i64> Uids,
}


struct ResPlayerProfileData {
	1: i64 dwUin,
	2: i32 ImageFrame,
	3: i32 ImageIcon,
	4: i32 DecorateCnt,
	5: string NickName,
	6: string PicURL,
	7: string UnlockFrame,
	8: string UnlockIcon,
	9: i32 ActiveTime,
}


struct ResPlayerRank {
	1: i64 Uid,
	2: string Name,
	3: i32 Face,
	4: i32 Avatar,
	5: i32 Level,
	6: double score,
	7: i32 type,
	8: map<i32, i32> PlayroomSet,
	9: map<i32, i32> DressSet,
	10: i32 FurSet,
	11: ActLog Last,
	12: string PetName,
	13: i32 Rank,
}


struct ResPlayerSimple {
	1: i64 Uid,
	2: string Name,
	3: i32 Face,
	4: i32 Avatar,
	5: i32 Level,
	6: i32 Decorate,
	7: i32 login,
	8: i32 loginout,
	9: string Facebook,
	10: map<i32, i32> Emoji
	11: i64 AddTime,
	12: i64 Interact,
}


struct ResPlayroom {
	1: i32 status,
	2: list<ItemInfo> Items,
	3: list<RoomOpponent> Opponent,
	4: list<FriendRoom> Friend,
	5: map<i32, i32> Playroom
	6: list<PlayroomCollectInfo> collect,
	7: map<i32, i32> Mood
	8: list<ItemInfo> LoseItem,
	9: i32 StartTime,
	10: i32 WorkStatus,
	11: i32 AllMood,
	12: list<ChipInfo> Chip,
	13: i32 WorkOutline,
	14: i32 Jackpot,
	15: map<i32, i32> Physiology
	16: map<i32, PlayroomDress> Dress
	17: map<i32, i32> DressSet
	18: list<PlayroomAirInfo> PetAir,
	19: i32 PetAirSet,
	20: i32 Upvote,
	21: i32 RoomPoint,
	22: list<i32> Unlock,
	23: list<DailyTask> DailyTask,
	24: list<i32> DailyTaskReward,
	25: i32 InteractNum,
	26: i32 Kiss,
	27: i64 Revenge,
	28: list<AdItem> AdItem,
	29: FriendRoom Target,
	30: map<i32, WeeklyDiscountInfo> WeeklyDiscount
	31: i32 DailyGameTimes, // 每日游戏次数
}


struct ResPlayroomBuyItem {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomChip {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomDraw {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResPlayroomDressSet {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomFlip {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
	4: i32 CardId,
}


struct ResPlayroomFlipReward {
	1: RES_CODE Code,
	2: string Msg,
	3: bool Broken,
}


struct ResPlayroomGame {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Type,
	4: map<i32, ItemInfo> Items
}


struct ResPlayroomGameShowReward {
	1: list<ItemInfo> Items,
}


struct ResPlayroomGuide {
	1: RES_CODE Code,
	2: string Msg,
}

struct ReqPlayroomGameInfo {
	1: i32 GameId,
}

struct ResPlayroomGameInfo {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 GameId,
	4: map<i32, ItemInfo> Items
}


struct ResPlayroomInfo {
	1: i64 Uid,
	2: string name,
	3: i32 Face,
	4: i32 Avatar,
	5: map<i32, i32> Playroom
	6: i32 GameId,
	7: map<i32, ItemInfo> Items
	8: i32 Status,
	9: bool defense,
	10: map<i32, i32> Flip
	11: i32 Chip,
	12: string PetName,
	13: map<i32, i32> Emoji
	14: bool Upvote,
	15: i32 UpvoteCount,
	16: map<i32, i32> DressSet
	17: i32 Kiss,
	18: i32 Fur,
	19: i32 Star,
	20: bool DailyGame, // 是否已完成每日游戏
	21: bool DailyStroken, // 是否已完成每日抚摸
}


struct ResPlayroomInteract {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 InteractNum,
}


struct ResPlayroomLose {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomOutline {
	1: RES_CODE code,
	2: string msg,
}


struct ResPlayroomPetAirSet {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomRest {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomSelectReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomSetRoom {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomShop {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomTask {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResPlayroomTaskReward {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
	4: i32 Type,
}


struct ResPlayroomUnlock {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResPlayroomUpvote {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Id,
}


struct ResPlayroomWork {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPlayroomWorkOutline {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResPutChessInBag {
	1: RES_CODE code,
	2: string msg,
}


struct ResPutPartInBag {
	1: RES_CODE code,
	2: string msg,
}


struct ResRace {
	1: i32 Id,
	2: i32 Status,
	3: i32 EndTime,
	4: i32 Template,
	5: i32 Pass,
	6: i32 GameStartTime,
	7: i32 GameEndTime,
	8: i32 Progress,
	9: list<raceopponent> Opponent,
	10: i32 Rank,
}


struct ResRaceReward {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResRaceStart {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResRank {
	1: i32 Type,
	2: map<i32, ResPlayerSimple> RankList
	3: i32 MyRank,
	4: double MyScore,
}


struct ResReadMail {
	1: RES_CODE Code,
	2: string Msg,
	3: i32 Id,
}


struct ResRefreshChessShop {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResRefuseCardExchange {
	1: RES_CODE Code,
	2: string Msg,
	3: string Id,
}


struct ResRefuseCardGive {
	1: RES_CODE Code,
	2: string Msg,
	3: string Id,
}


struct ResRefuseCardSelect {
	1: RES_CODE Code,
	2: string Msg,
	3: string Id,
}


struct ResRefuseFriend {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
}


struct ResRegisterAccount {
	1: i32 ResultCode,
}


struct ResRemoveAd {
	1: i32 ResultCode,
}


struct ResRewardOrder {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSearchPlayer {
	1: i32 Code,
	2: list<ResPlayerSimple> List,
}


struct ResSelectCardExchange {
	1: RES_CODE Code,
	2: string Msg,
	3: string Id,
}


struct ResSelectLimitEvent {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSelfInvited {
	1: i32 ResultCode,
}


struct ResSellChessNum {
	1: i32 Num,
}


struct ResSendWishBeg {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSeparateChess {
	1: RES_CODE code,
	2: string msg,
}


struct ResServerTime {
	1: i32 ServerTime,
}


struct ResServerVersion {
	1: i32 Version,
}


struct ResSetAvatar {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSetEmoji {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSetEnergyMul {
	1: RES_CODE ResultCode,
	2: string Msg,
}


struct ResSetFace {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSetFacebookUrl {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSetName {
	1: RES_CODE ResultCode,
	2: string Msg,
}


struct ResSetPetName {
	1: RES_CODE ResultCode,
	2: string Msg,
}


struct ResSevenLogin {
	1: list<SevenLoginReward> WeekReward,
	2: list<SevenLoginReward> MonthReward,
	3: i32 Active,
	4: bool IsBack,
}


struct ResShippingOrder {
	1: RES_CODE Code,
	2: string Msg,
}


struct ResSourceChest {
	1: RES_CODE code,
	2: string msg,
}


struct ResSpecialShop {
	1: i32 Grade,
	2: i32 Count,
}


struct ResSynGameData {
	1: i64 dwUin,
	2: i32 ResultCode,
}


struct ResTakeChessOutBag {
	1: RES_CODE code,
	2: string msg,
}


struct ResTakeChessOutBagToHonor {
	1: RES_CODE code,
	2: string msg,
}


struct ResUnBindFacebook {
	1: i32 ResultCode,
	2: string BindAccountId,
}


struct ResUpdatePlayerChessData {
	1: RES_CODE code,
	2: string msg,
}


struct ResUpgradeChess {
	1: RES_CODE code,
	2: string msg,
}


struct ResUserDetail {
	1: i32 Code,
	2: string Msg,
	3: ResUserDetailInfo info,
}


struct ResUserDetailInfo {
	1: string Name,
	2: i64 Uid,
	3: i32 AreaId,
	4: i32 Face,
	5: i32 Charge,
	6: i32 MaxCharge,
	7: i32 Level,
	8: i64 Diamond,
	9: i32 Star,
	10: i32 Energy,
	11: string Mac,
	12: i64 Login,
	13: i64 Cumulative,
	14: i64 RegisterTime,
	15: i64 TodayCumulative,
	16: bool Ban,
	17: i32 Bonus,
	18: string Code,
	19: map<string, i32> ChessMap
	20: list<ActLog> ActLog,
	21: i32 AdWatch,
	22: list<UserDetailFriendInfo> FriendList,
	23: list<UserDetailOrderInfo> Order,
}


struct ResWishApply {
	1: RES_CODE Code,
	2: string Msg,
	3: i64 Uid,
}


struct ResWishApplyList {
	1: list<ResFriendApplyInfo> ApplyList,
}


struct RoomOpponent {
	1: i64 Uid,
	2: string Name,
	3: i32 Face,
	4: i32 Avatar,
	5: i32 LastTime,
}


struct SevenLoginReward {
	1: list<ItemInfo> Item1,
	2: list<ItemInfo> Item2,
	3: list<ItemInfo> Item3,
	4: i32 Status,
	5: i32 Id,
	6: i32 NeedActive,
}


enum TIME_LINE_TYPE {
	Default = 0
	LogTypeFriendApply = 1
	LogTypeFriendBecome = 2
	LogTypeCardExSend = 3
	LogTypeCardSend = 4
	LogTypeCardGive = 5
	LogTypeCardSelectGet = 6
	LogTypeCardAcceptGive = 7
	LogTypeCardExGet = 8
	LogTypeCardSelectSend = 9
	LogTypeCardExSuccess1 = 10
	LogTypeCardExSuccess2 = 11
	LogTypeFriendDelete = 14
	LogTypePlayroomVisit = 15
	LogTypeHandbook = 16
	LogTypeHandbookUpvote = 17
	LogTypeChargeSend = 18
	LogTypeChargeReceived = 19
	LogTypeWish = 20
	LogTypeFriendBecomeNpc = 21
	LogTypePlayroomUpvote = 22
	LogTypePlayroomChampship = 23
	LogTypeTreasure = 24
	LogTypeCardSendAccept = 25
	LogTypePlayroomCatWin = 26
	LogTypePlayroomCatLose = 27
	LogTypeCardGiveAccept = 28
	LogTypeFriendInvite = 29
	LogTypeTreasureHelp = 30
	LogTypeFriendSponsor = 31
	LogTypeFriendSponsorGet = 32
	LogTypePlayroomBankruptcy = 33
	LogTypeStrokeKitten = 34
}


struct TreasureInfo {
	1: i32 Pos,
	2: i32 Type,
	3: i32 Face,
	4: i32 Avatar,
	5: i64 Uid,
	6: i32 Status,
	7: string NickName,
}


struct UpdateBaseItemInfo {
	1: i64 dwUin,
	2: map<i32, i32> MUpdateItem
}


struct UpdatePlayerChessData {
	1: i64 dwUin,
	2: map<string, i32> MChessData
	3: list<ChessHandle> mChessHandle,
}


struct UserDetailFriendInfo {
	1: i64 Uid,
	2: string NickName,
	3: i32 Avatar,
	4: i32 Level,
	5: i64 LogoutTime,
	6: i64 LoginTime,
	7: string AvatarUrl,
	8: bool OnlineStatus,
}


struct UserDetailOrderInfo {
	1: string Id,
	2: i32 Type,
	3: i64 Time,
	4: list<UserDetailOrderInfoChess> Chess,
	5: i32 Diff,
	6: list<UserDetailOrderInfoChess> ChessId,
}


struct UserDetailOrderInfoChess {
	1: i32 Id,
	2: string Icon,
}


struct UserDetailParam {
	1: i64 Uid,
}


struct UserInfo {
	1: i64 Uid,
	2: string Nickname,
	3: i32 Avatar,
	4: i32 Face,
	5: i32 DecorateCnt,
	6: list<AvatarInfo> AvatarList,
	7: list<FaceInfo> FaceList,
	8: i32 Login,
	9: string PetName,
	10: list<EmojiInfo> EmojiList,
	11: map<i32, i32> SetEmoji
	12: string IdNum,
	13: string AddCode,
}


struct WeeklyDiscountInfo {
	1: i32 Id,
	2: i32 Count,
	3: i32 Discount,
}


struct WishList {
	1: i32 Id,
	2: i32 Count,
	3: list<i64> Uid,
}


struct opponent {
	2: string Name,
	3: i32 Face,
	4: i32 Avatar,
	5: i32 Progress,
}


struct raceopponent {
	1: i32 Id,
	2: i32 Face,
	3: i32 Avatar,
	4: string Name,
	5: i32 Progress,
}

struct ReqStrokingKitten {}

struct ResStrokingKitten{
	1: RES_CODE Code,
	2: string Msg,
	3: list<ItemInfo> Items,
}

struct ReqMiniGameInfo {}

struct ResMiniGameInfo{
	1: list<MiniGame> MiniGameList, // 游戏列表
	2: i32 DailyPExp, // 每日获得的PExp
}

struct MiniGame {
	1: i32 Id,	// 游戏id
	2: list<i32> Reward, // 已领取一次性奖励
}
