SCHALE.GameServer/SCHALE.Common/Database/dbs.cs

using System;
using System.Collections;
using System.Collections.ObjectModel;
using System.Runtime.CompilerServices;
using System.Text.Json;
using System.Text.Json.Serialization;
using Google.FlatBuffers;
using SCHALE.Common.FlatData;
using SCHALE.Common.NetworkProtocol;
using SCHALE.Common.NetworkProtocol;

namespace SCHALE.Common.Database
{
	public class AcademyLocationDB
	{
		public long LocationId { get; set; }
		public long Rank { get; set; }
		public long Exp { get; set; }
	}

	public class AcademyMessageOutLineDB
	{
		public long CharacterUniqueId { get; set; }
		public long NewMessageCount { get; set; }
		public long LastMessageUniqueId { get; set; }
		public long LastMessageServerId { get; set; }
	}

	public class AcademyMessageDB
	{
		public long MessageServerId { get; set; }
		public long MessageGroupId { get; set; }
		public long MessageUniqueId { get; set; }
		public long SelectedMessageUniqueId { get; set; }
		public long CharacterServerId { get; set; }
		public long CharacterUniqueId { get; set; }
		public bool IsRead { get; set; }
	}

	public class AcademyScheduleDB
	{
		public long ScheduleUniqueId { get; set; }
		public long ScheduleGroupId { get; set; }
		public long ZoneUniqueId { get; set; }
		public DateTime LastUpdateDate { get; set; }
		public int CompleteCount { get; set; }
	}

	public class AccountAchievementDB
	{
		public long AchievementUniqueId { get; set; }
		public long AchievementValue { get; set; }
	}

	public class AccountAttachmentDB
	{
		public long AccountId { get; set; }
		public long EmblemUniqueId { get; set; }
	}

	public class AccountCurrencyDB
	{
		public long AccountLevel { get; set; }
		public long AcademyLocationRankSum { get; set; }
		public Dictionary<CurrencyTypes, long> CurrencyDict { get; set; }
		public Dictionary<CurrencyTypes, DateTime> UpdateTimeDict { get; set; }
	}

	public class AccountRestrictionsDB
	{
		public bool NicknameRestriction { get; set; }
		public bool CommentRestriction { get; set; }
		public bool CallnameRestriction { get; set; }
	}

	public class ArenaHistoryDB
	{
		public ArenaBattleDB ArenaBattleDB { get; set; }
	
		[JsonIgnore]
		public DateTime BattleEndTime { get; }
	
		[JsonIgnore]
		public BattleSummary BattleSummary { get; }
	
		[JsonIgnore]
		public ArenaUserDB AttackingUserDB { get; }
	
		[JsonIgnore]
		public ArenaUserDB DefendingUserDB { get; }
	
		[JsonIgnore]
		public long WinnerAccountServerId { get; }
	}

	public class ArenaPlayerInfoDB
	{
		public long CurrentSeasonId { get; set; }
		public long PlayerGroupId { get; set; }
		public long CurrentRank { get; set; }
		public long SeasonRecord { get; set; }
		public long AllTimeRecord { get; set; }
		public long CumulativeTimeReward { get; set; }
		public DateTime TimeRewardLastUpdateTime { get; set; }
		public DateTime BattleEnterActiveTime { get; set; }
		public DateTime DailyRewardActiveTime { get; set; }
	}

	public class ArenaBattleDB
	{
		public long ArenaBattleServerId { get; set; }
		public long Season { get; set; }
		public long Group { get; set; }
		public DateTime BattleStartTime { get; set; }
		public DateTime BattleEndTime { get; set; }
		public long Seed { get; set; }
		public ArenaUserDB AttackingUserDB { get; set; }
		public ArenaUserDB DefendingUserDB { get; set; }
		public BattleSummary BattleSummary { get; set; }
	}

	public class ArenaUserDB
	{
		public long AccountServerId { get; set; }
		public long RepresentCharacterUniqueId { get; set; }
		public long RepresentCharacterCostumeId { get; set; }
		public string NickName { get; set; }
		public long Rank { get; set; }
		public long Level { get; set; }
		public long Exp { get; set; }
		public ArenaTeamSettingDB TeamSettingDB { get; set; }
		public AccountAttachmentDB AccountAttachmentDB { get; set; }
		public string UserName { get; }
	}

	public class ArenaTeamSettingDB
	{
		public EchelonType EchelonType { get; set; }
		public long LeaderCharacterId { get; set; }
		public long TSSInteractionCharacterId { get; set; }
	
		[JsonIgnore]
		public long TSSInteractionCharacterServerId { get; }
		public IList<ArenaCharacterDB> MainCharacters { get; set; }
		public IList<ArenaCharacterDB> SupportCharacters { get; set; }
		public ArenaCharacterDB TSSCharacterDB { get; set; }
	
		[JsonIgnore]
		public int SquadCount { get; }
		public long MapId { get; set; }
	}

	public class ArenaCharacterDB
	{
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public int StarGrade { get; set; }
		public int Level { get; set; }
		public int PublicSkillLevel { get; set; }
		public int ExSkillLevel { get; set; }
		public int PassiveSkillLevel { get; set; }
		public int ExtraPassiveSkillLevel { get; set; }
		public int LeaderSkillLevel { get; set; }
		public List<EquipmentDB> EquipmentDBs { get; set; }
		public Dictionary<long, long> FavorRankInfo { get; set; }
		public Dictionary<int, int> PotentialStats { get; set; }
		public int CombatStyleIndex { get; set; }
		public WeaponDB WeaponDB { get; set; }
		public GearDB GearDB { get; set; }
		public CostumeDB CostumeDB { get; set; }
	}

	public class ArenaDamageReportDB
	{
		public long ArenaBattleServerId { get; set; }
		public long WinnerAccountServerId { get; set; }
		public ArenaUserDB AttackerUserDB { get; set; }
		public ArenaUserDB DefenderUserDB { get; set; }
		public DateTime BattleEndTime { get; set; }
		public Dictionary<long, long> AttackerDamageReport { get; set; }
		public Dictionary<long, long> DefenderDamageReport { get; set; }
	}

	public enum AssistRelation
	{
		None = 0,
		Clan = 1,
		Friend = 2,
		Cheat = 4,
		Stranger = 8,
	}

	public class AssistCharacterDB : CharacterDB
	{
		private CostumeDB _costumeDB;
		public EchelonType EchelonType { get; set; }
		public int SlotNumber { get; set; }
		public long AccountId { get; set; }
		public AssistRelation AssistRelation { get; set; }
		public long AssistCharacterServerId { get; set; }
		public string NickName { get; set; }
		public List<EquipmentDB> EquipmentDBs { get; set; }
		public WeaponDB WeaponDB { get; set; }
		public GearDB GearDB { get; set; }
		public long CostumeId { get; set; }
		public CostumeDB CostumeDB { get; }
		public bool IsMulligan { get; set; }
		public bool IsTSAInteraction { get; set; }
		public int CombatStyleIndex { get; set; }
	
		[JsonIgnore]
		public bool HasWeapon { get; }
	
		[JsonIgnore]
		public bool HasGear { get; }
	}

	public class AttendanceHistoryDB
	{
		public long ServerId { get; set; }
		public long AttendanceBookUniqueId { get; set; }
		public Dictionary<long, DateTime> AttendedDay { get; set; }
		public bool Expired { get; set; }
	
		[JsonIgnore]
		public long LastAttendedDay { get; }
	
		[JsonIgnore]
		public DateTime LastAttendedDate { get; }
	
		[JsonIgnore]
		public Dictionary<long, Nullable<DateTime>> AttendedDayNullable { get; }
	}

	public class BanDB
	{
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public DateTime BanStartDate { get; set; }
		public DateTime BanEndDate { get; set; }
		public DateTime RegisterDate { get; set; }
		public byte CancelFlag { get; set; }
		public DateTime CancelDate { get; set; }
		public string Reason { get; set; }
	}

	public class BeforehandGachaSnapshotDB
	{
		public long ShopUniqueId { get; set; }
		public long GoodsId { get; set; }
		public long LastIndex { get; set; }
		public List<long> LastResults { get; set; }
		public Nullable<long> SavedIndex { get; set; }
		public List<long> SavedResults { get; set; }
		public Nullable<long> PickedIndex { get; set; }
	}

	public enum ShopCashBlockType
	{
		All = -1,
		AppStore = -2,
		GooglePlay = -3,
		None = -9999,
	}

	public class BlockedProductDB
	{
		public long CashProductId { get; set; }
		public ShopCashBlockType MarketBlockType { get; }
		public DateTime BeginDate { get; set; }
		public DateTime EndDate { get; set; }
	}

	public class CafeProductionDB
	{
		public long CafeDBId { get; set; }
		public long ComfortValue { get; set; }
		public DateTime AppliedDate { get; set; }
		public List<CafeProductionParcelInfo> ProductionParcelInfos { get; set; }
	}

	public class CafePresetDB
	{
		public long ServerId { get; set; }
		public int SlotId { get; set; }
		public string PresetName { get; set; }
		public bool IsEmpty { get; set; }
	}

	public class EventContentMainStageSaveDB : CampaignMainStageSaveDB
	{
		public override ContentType ContentType { get; }
		public Dictionary<long, long> SelectedBuffDict { get; set; }
	
		[JsonIgnore]
		public bool IsBuffSelectPopupOpen { get; }
		public long CurrentAppearedBuffGroupId { get; set; }
	}

	public class CampaignMainStageSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
		public CampaignState CampaignState { get; set; }
		public int CurrentTurn { get; set; }
		public int EnemyClearCount { get; set; }
		public int LastEnemyEntityId { get; set; }
		public int TacticRankSCount { get; set; }
		public Dictionary<long, HexaUnit> EnemyInfos { get; set; }
		public Dictionary<long, HexaUnit> EchelonInfos { get; set; }
		public Dictionary<long, List<long>> WithdrawInfos { get; set; }
		public Dictionary<long, Strategy> StrategyObjects { get; set; }
		public Dictionary<long, List<ParcelInfo>> StrategyObjectRewards { get; set; }
		public List<long> StrategyObjectHistory { get; set; }
		public Dictionary<long, List<long>> ActivatedHexaEventsAndConditions { get; set; }
		public Dictionary<long, List<long>> HexaEventDelayedExecutions { get; set; }
		public Dictionary<int, HexaTileState> TileMapStates { get; set; }
		public List<HexaDisplayInfo> DisplayInfos { get; set; }
		public List<HexaUnit> DeployedEchelonInfos { get; set; }
	}

	public class DailyResetCountDB
	{
		public long AccountServerId { get; set; }
		public Dictionary<ResetContentType, long> ResetCount { get; set; }
	}

	public class CampaignSubStageSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class CampaignExtraStageSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class EventContentSubStageSaveDB : CampaignSubStageSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class EventContentMainGroundStageSaveDB : CampaignSubStageSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class EventContentStoryStageSaveDB : CampaignSubStageSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class CampaignTutorialStageSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class CardShopElementDB
	{
		public long EventContentId { get; set; }
		public int SlotNumber { get; set; }
		public long CardShopElementId { get; set; }
		public bool SoldOut { get; }
	}

	public class CardShopPurchaseHistoryDB
	{
		public long EventContentId { get; set; }
		public Rarity Rarity { get; set; }
		public long PurchaseCount { get; set; }
	}

	public class ClanAssistRentHistoryDB
	{
		public long AssistCharacterAccountId { get; set; }
		public long AssistCharacterDBId { get; set; }
		public DateTime RentDate { get; set; }
		public long AssistCharacterId { get; set; }
	}

	public class ClanAssistSlotDB
	{
		public EchelonType EchelonType { get; set; }
		public long SlotNumber { get; set; }
		public long CharacterDBId { get; set; }
		public DateTime DeployDate { get; set; }
		public long TotalRentCount { get; set; }
		public int CombatStyleIndex { get; set; }
	}

	public class ClanAssistRewardInfo
	{
		public long CharacterDBId { get; set; }
		public DateTime DeployDate { get; set; }
		public long RentCount { get; set; }
		public List<ParcelInfo> CumultativeRewardParcels { get; set; }
		public List<ParcelInfo> RentRewardParcels { get; set; }
	}

	public class ClanAssistUseInfo
	{
		public long CharacterAccountId { get; set; }
		public long CharacterDBId { get; set; }
		public EchelonType EchelonType { get; set; }
		public int SlotNumber { get; set; }
		public AssistRelation AssistRelation { get; set; }
		public int EchelonSlotType { get; set; }
		public int EchelonSlotIndex { get; set; }
		public int CombatStyleIndex { get; set; }
	
		[JsonIgnore]
		public long DecodedShardId { get; }
	
		[JsonIgnore]
		public long DecodedCharacterDBId { get; }
		public bool IsMulligan { get; set; }
		public bool IsTSAInteraction { get; set; }
	}

	public class ClanDB
	{
		public long ClanDBId { get; set; }
		public string ClanName { get; set; }
		public string ClanChannelName { get; set; }
		public string ClanPresidentNickName { get; set; }
		public long ClanPresidentRepresentCharacterUniqueId { get; set; }
		public long ClanPresidentRepresentCharacterCostumeId { get; set; }
		public string ClanNotice { get; set; }
		public long ClanMemberCount { get; set; }
		public ClanJoinOption ClanJoinOption { get; set; }
	}

	public class ClanMemberDB
	{
		public long AccountId { get; set; }
		public long AccountLevel { get; set; }
		public string AccountNickName { get; set; }
		public long ClanDBId { get; set; }
		public long RepresentCharacterUniqueId { get; set; }
		public long RepresentCharacterCostumeId { get; set; }
		public long AttendanceCount { get; set; }
		public long CafeComfortValue { get; set; }
		public ClanSocialGrade ClanSocialGrade { get; set; }
		public DateTime JoinDate { get; set; }
		public DateTime SocialGradeUpdateTime { get; set; }
		public DateTime LastLoginDate { get; set; }
		public DateTime GameLoginDate { get; set; }
		public DateTime AppliedDate { get; set; }
		public AccountAttachmentDB AttachmentDB { get; set; }
	}

	public class ClanMemberDescriptionDB
	{
		public long Exp { get; set; }
		public string Comment { get; set; }
		public int CollectedCharactersCount { get; set; }
		public long ArenaSeasonBestRanking { get; set; }
		public long ArenaSeasonCurrentRanking { get; set; }
	}

	public struct ClearDeckKey : IEquatable<ClearDeckKey>
	{
		public ContentType ContentType { get; set; }
		public long[] Arguments { get; set; }
		public bool Equals(ClearDeckKey other)
		{
			return default;
		}

	}

	public class ClearDeckDB
	{
		public List<ClearDeckCharacterDB> ClearDeckCharacterDBs { get; set; }
		public List<long> MulliganUniqueIds { get; set; }
		public long LeaderUniqueId { get; set; }
		public long TSSInteractionUniqueId { get; set; }
		public EchelonType EchelonType { get; set; }
		public long EchelonExtensionType { get; set; }
	}

	public class ClearDeckCharacterDB
	{
		public long UniqueId { get; set; }
		public int StarGrade { get; set; }
		public int Level { get; set; }
		public int SlotNumber { get; set; }
		public bool HasWeapon { get; set; }
		public SquadType SquadType { get; set; }
		public int WeaponStarGrade { get; set; }
		public int CombatStyleIndex { get; set; }
	}

	public class ConquestEchelonDB
	{
		public long EventContentId { get; set; }
		public StageDifficulty Difficulty { get; set; }
		public long TileUniqueId { get; set; }
		public EchelonDB EchelonDB { get; set; }
		public long AssistCharacterUniqueId { get; set; }
		public ClanAssistUseInfo AssistUseInfo { get; set; }
	}

	public class ConquestErosionDB : ConquestEventObjectDB
	{
		public override ConquestEventObjectType ObjectType { get; }
	
		[JsonIgnore]
		public long ErosionId { get; }
		public long ConditionSnapshot { get; set; }
		public DateTime CreateDate { get; set; }
	}

	public abstract class ConquestEventObjectDB
	{
		public long ConquestObjectDBId { get; set; }
		public long EventContentId { get; set; }
		public StageDifficulty Difficulty { get; set; }
		public long TileUniqueId { get; set; }
		public long ObjectId { get; set; }
		public virtual ConquestEventObjectType ObjectType { get; }
		public bool IsAlive { get; set; }
	}

	public class ConquestInfoDB
	{
		public long EventContentId { get; set; }
		public int EventGauge { get; set; }
		public int EventSpawnCount { get; set; }
		public int EchelonChangeCount { get; set; }
		public int TodayConquestRentCount { get; set; }
		public int TodayOperationRentCount { get; set; }
		public long CumulatedConditionValue { get; set; }
		public long ReceivedCalculateRewardConditionAmount { get; set; }
	
		[JsonIgnore]
		public long CalculateRewardConditionValue { get; }
		public Nullable<long> AlertMassErosionId { get; set; }
	}

	public class ConquestStageSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
		public Nullable<long> ConquestEventObjectDBId { get; set; }
		public long EventContentId { get; set; }
		public StageDifficulty Difficulty { get; set; }
		public long TileUniqueId { get; set; }
		public long TilePresetId { get; set; }
		public ConquestTileType ConquestTileType { get; set; }
		public bool UseManageEchelon { get; set; }
		public AssistCharacterDB AssistCharacterDB { get; set; }
		public int EchelonSlotType { get; set; }
		public int EchelonSlotIndex { get; set; }
	}

	public class ConquestSummary
	{
		public long EventContentId { get; set; }
		public StageDifficulty Difficulty { get; set; }
		public Dictionary<int, ConquestStepSummary> ConquestStepSummaryDict { get; set; }
	}

	public class ConquestStepSummary
	{
		public long ConqueredTileCount { get; set; }
		public long AllTileCount { get; set; }
		public long ErosionRemainingCount { get; set; }
		public bool HasPhaseComplete { get; set; }
		public bool IsErosionPhaseStart { get; set; }
		public bool IsStepOpen { get; set; }
	}

	public class ConquestMainStorySummary
	{
		public long EventContentId { get; set; }
		public StageDifficulty Difficulty { get; set; }
		public Dictionary<int, ConquestMainStoryStepSummary> ConquestStepSummaryDict { get; set; }
	}

	public class ConquestMainStoryStepSummary
	{
		public long ConqueredTileCount { get; set; }
		public long AllTileCount { get; set; }
		public bool IsStepOpen { get; set; }
	}

	public class ConquestTileDB
	{
		public long EventContentId { get; set; }
		public StageDifficulty Difficulty { get; set; }
		public long TileUniqueId { get; set; }
		public TileState TileState { get; set; }
		public long Level { get; set; }
		public bool[] StarFlags { get; set; }
		public DateTime CreateTime { get; set; }
		public bool IsThreeStarClear { get; }
		public bool IsAnyStarClear { get; }
	
		[JsonIgnore]
		public long BestStarRecord { get; }
	}

	public class ConquestTreasureBoxDB : ConquestEventObjectDB
	{
		public override ConquestEventObjectType ObjectType { get; }
	}

	public class ConquestUnexpectedEnemyDB : ConquestEventObjectDB
	{
	
		[JsonIgnore]
		public long UnitId { get; }
		public override ConquestEventObjectType ObjectType { get; }
	}

	public interface IConsumableItemBaseExcel
	{
		public abstract ParcelType Type { get; }
		public abstract long UniqueId { get; }
		public abstract long ShiftingCraftQuality { get; }
		public abstract long StackableMax { get; }
		public abstract Rarity Rarity { get; }
		public abstract IReadOnlyList<Tag> Tags { get; }
		public abstract IReadOnlyDictionary<CraftNodeTier, long> CraftQualityDict { get; }
	}

	public class ItemExcelData : IConsumableItemBaseExcel
	{
		public virtual ParcelType Type { get; }
		public virtual long UniqueId { get; }
		public virtual long ShiftingCraftQuality { get; }
		public virtual long StackableMax { get; }
		public virtual Rarity Rarity { get; }
		public virtual IReadOnlyList<Tag> Tags { get; set; }
		public virtual IReadOnlyDictionary<CraftNodeTier, long> CraftQualityDict { get; set; }
		private ItemExcel _excel { get; }
		public bool TryGetCraftQuality(CraftNodeTier tier, long quality)
		{
			return default;
		}

	}

	public class FurnitureExcelData : IConsumableItemBaseExcel
	{
		public virtual ParcelType Type { get; }
		public virtual long UniqueId { get; }
		public virtual long ShiftingCraftQuality { get; }
		public virtual long StackableMax { get; }
		public virtual Rarity Rarity { get; }
		public virtual IReadOnlyList<Tag> Tags { get; set; }
		public virtual IReadOnlyDictionary<CraftNodeTier, long> CraftQualityDict { get; set; }
		private FurnitureExcel _excel { get; }
		public bool TryGetCraftQuality(CraftNodeTier tier, long quality)
		{
			return default;
		}

	}

	public class EquipmentExcelData : IConsumableItemBaseExcel
	{
		public virtual ParcelType Type { get; }
		public virtual long UniqueId { get; }
		public virtual long ShiftingCraftQuality { get; }
		public virtual long StackableMax { get; }
		public virtual Rarity Rarity { get; }
		public virtual IReadOnlyList<Tag> Tags { get; set; }
		public virtual IReadOnlyDictionary<CraftNodeTier, long> CraftQualityDict { get; set; }
		private EquipmentExcel _excel { get; }
		public bool TryGetCraftQuality(CraftNodeTier tier, long quality)
		{
			return default;
		}

	}

	public class ConsumeRequestDB
	{
		public Dictionary<long, long> ConsumeItemServerIdAndCounts { get; set; }
		public Dictionary<long, long> ConsumeEquipmentServerIdAndCounts { get; set; }
		public Dictionary<long, long> ConsumeFurnitureServerIdAndCounts { get; set; }
	
		[JsonIgnore]
		public bool IsItemsValid { get; }
	
		[JsonIgnore]
		public bool IsEquipmentsValid { get; }
	
		[JsonIgnore]
		public bool IsFurnituresValid { get; }
	
		[JsonIgnore]
		public bool IsValid { get; }
	}

	public class ConsumeResultDB
	{
		public List<long> RemovedItemServerIds { get; set; }
		public List<long> RemovedEquipmentServerIds { get; set; }
		public List<long> RemovedFurnitureServerIds { get; set; }
		public Dictionary<long, long> UsedItemServerIdAndRemainingCounts { get; set; }
		public Dictionary<long, long> UsedEquipmentServerIdAndRemainingCounts { get; set; }
		public Dictionary<long, long> UsedFurnitureServerIdAndRemainingCounts { get; set; }
	}

	public class EquipmentBatchGrowthRequestDB
	{
		public long TargetServerId { get; set; }
		public List<ConsumeRequestDB> ConsumeRequestDBs { get; set; }
		public long AfterTier { get; set; }
		public long AfterLevel { get; set; }
		public long AfterExp { get; set; }
		public List<SelectTicketReplaceInfo> ReplaceInfos { get; set; }
	}

	public class SkillLevelBatchGrowthRequestDB
	{
		public SkillSlot SkillSlot { get; set; }
		public int Level { get; set; }
		public List<SelectTicketReplaceInfo> ReplaceInfos { get; set; }
	}

	public class SelectTicketReplaceInfo
	{
		public ParcelType MaterialType { get; set; }
		public long MaterialId { get; set; }
		public long TicketItemId { get; set; }
		public int Amount { get; set; }
	}

	public class GearTierUpRequestDB
	{
		public long TargetServerId { get; set; }
		public long AfterTier { get; set; }
		public List<SelectTicketReplaceInfo> ReplaceInfos { get; set; }
	}

	public class PotentialGrowthRequestDB
	{
		public PotentialStatBonusRateType Type { get; set; }
		public int Level { get; set; }
	}

	public abstract class ContentSaveDB
	{
		public abstract ContentType ContentType { get; }
		public long AccountServerId { get; set; }
		public DateTime CreateTime { get; set; }
		public long StageUniqueId { get; set; }
		public long LastEnterStageEchelonNumber { get; set; }
		public List<ParcelInfo> StageEntranceFee { get; set; }
		public Dictionary<long, long> EnemyKillCountByUniqueId { get; set; }
		public long TacticClearTimeMscSum { get; set; }
		public long AccountLevelWhenCreateDB { get; set; }
		public string BIEchelon { get; set; }
		public string BIEchelon1 { get; set; }
		public string BIEchelon2 { get; set; }
		public string BIEchelon3 { get; set; }
		public string BIEchelon4 { get; set; }
	}

	public abstract class ContentsValueChangeDB
	{
		public abstract ContentsChangeType ContentsChangeType { get; }
	}

	public class CostumeDB : ParcelBase
	{
		public override ParcelType Type { get; }
	
		[JsonIgnore]
		public override IEnumerable<ParcelInfo> ParcelInfos { get; }
		public long UniqueId { get; set; }
		public long BoundCharacterServerId { get; set; }
	}

	public enum CraftProcessCompleteType
	{
		None = 0,
		ByTimeElapse = 1,
		ByPlayer = 2,
	}

	public enum CraftState
	{
		None = 0,
		BaseNode = 1,
		NodeSelecting = 2,
		Crafting = 3,
		Complete = 4,
	}

	public class CraftInfoDB
	{
		public long SlotSequence { get; set; }
		public DateTime StartTime { get; set; }
		public DateTime EndTime { get; set; }
		public DateTime CraftSlotOpenDate { get; set; }
		public List<CraftNodeDB> Nodes { get; set; }
	
		[JsonIgnore]
		public IEnumerable<long> ResultIds { get; }
	
		[JsonIgnore]
		public IEnumerable<ParcelInfo> RewardParcelInfos { get; }
	}

	public class CraftNodeDB
	{
		public CraftNodeTier NodeTier { get; set; }
		public long SlotSequence { get; set; }
		public long NodeId { get; set; }
		public long NodeQuality { get; set; }
		public long NodeLevel { get; set; }
		public int NodeRandomSeed { get; set; }
		public int NodeRandomSequence { get; set; }
		public List<long> LeafNodeIds { get; set; }
		public long ResultId { get; set; }
		public CraftNodeResult CraftNodeResult { get; set; }
	
		[JsonIgnore]
		public ParcelInfo RewardParcelInfo { get; }
	}

	public class ShiftingCraftInfoDB
	{
		public long SlotSequence { get; set; }
		public long CraftRecipeId { get; set; }
		public long CraftAmount { get; set; }
		public DateTime StartTime { get; set; }
		public DateTime EndTime { get; set; }
	}

	public class CraftNodeResult
	{
		public CraftNodeTier NodeTier { get; set; }
		public ParcelInfo ParcelInfo { get; set; }
	}

	public class CraftPresetSlotDB
	{
		public List<CraftPresetNodeDB> PresetNodeDBs { get; set; }
	}

	public class CraftPresetNodeDB
	{
		public CraftNodeTier NodeTier { get; set; }
		public bool IsActivated { get; set; }
		public long PriortyNodeId { get; set; }
		public ConsumeRequestDB ConsumeRequestDB { get; set; }
	}

	public class DetailedAccountInfoDB
	{
		public long AccountId { get; set; }
		public string Nickname { get; set; }
		public long Level { get; set; }
		public string ClanName { get; set; }
		public string Comment { get; set; }
		public long FriendCount { get; set; }
		public string FriendCode { get; set; }
		public long RepresentCharacterUniqueId { get; set; }
		public long CharacterCount { get; set; }
		public Nullable<long> LastNormalCampaignClearStageId { get; set; }
		public Nullable<long> LastHardCampaignClearStageId { get; set; }
		public Nullable<long> ArenaRanking { get; set; }
		public Nullable<long> RaidRanking { get; set; }
		public Nullable<int> RaidTier { get; set; }
		public Nullable<long> EliminateRaidRanking { get; set; }
		public Nullable<int> EliminateRaidTier { get; set; }
		public AssistCharacterDB[] AssistCharacterDBs { get; set; }
	}

	public class EchelonPresetGroupDB
	{
		public int GroupIndex { get; set; }
		public EchelonExtensionType ExtensionType { get; set; }
		public string GroupLabel { get; set; }
		public Dictionary<int, EchelonPresetDB> PresetDBs { get; set; }
		public EchelonPresetDB Item { get; set; }
	}

	public class EchelonPresetDB
	{
		public int GroupIndex { get; set; }
		public int Index { get; set; }
		public string Label { get; set; }
		public long LeaderUniqueId { get; set; }
		public long TSSInteractionUniqueId { get; set; }
		public long[] StrikerUniqueIds { get; set; }
		public long[] SpecialUniqueIds { get; set; }
		public int[] CombatStyleIndex { get; set; }
		public List<long> MulliganUniqueIds { get; set; }
		public EchelonExtensionType ExtensionType { get; set; }
	
		[JsonIgnore]
		public int StrikerSlotCount { get; }
	
		[JsonIgnore]
		public int SpecialSlotCount { get; }
	}

	public class EmblemDB : ParcelBase
	{
		public override ParcelType Type { get; }
		public long UniqueId { get; set; }
		public DateTime ReceiveDate { get; set; }
		public override IEnumerable<ParcelInfo> ParcelInfos { get; }
	}

	public class EventContentBonusRewardDB
	{
		public long EventContentId { get; set; }
		public long EventStageUniqueId { get; set; }
		public ParcelInfo BonusParcelInfo { get; set; }
	}

	public class EventContentBoxGachaDB
	{
		public long EventContentId { get; set; }
		public long Seed { get; set; }
		public long Round { get; set; }
		public int PurchaseCount { get; set; }
	}

	public class EventContentBoxGachaData
	{
		public long EventContentId { get; set; }
		public Dictionary<long, EventContentBoxGachaVariation> Variations { get; set; }
	}

	public class EventContentBoxGachaVariation
	{
		public long EventContentId { get; set; }
		public long VariationId { get; set; }
		public Dictionary<long, EventContentBoxGachaRoundElement> GachaRoundElements { get; set; }
	}

	public class EventContentBoxGachaRoundElement
	{
		public long EventContentId { get; set; }
		public long VariationId { get; set; }
		public long Round { get; set; }
		public List<EventContentBoxGachaElement> Elements { get; set; }
	}

	public class EventContentBoxGachaElement
	{
		public long EventContentId { get; set; }
		public long VariationId { get; set; }
		public long Round { get; set; }
		public long GroupId { get; set; }
		public long UniqueId { get; set; }
		public bool IsPrize { get; set; }
		public List<ParcelInfo> Rewards { get; set; }
	}

	public class EventContentChangeDB
	{
		public long EventContentId { get; set; }
		public long UseAmount { get; set; }
		public long ChangeCount { get; set; }
		public long AccumulateChangeCount { get; set; }
		public DateTime LastUpdateDate { get; set; }
		public bool ChangeFlag { get; set; }
	}

	public class EventContentCollectionDB
	{
		public long EventContentId { get; set; }
		public long GroupId { get; set; }
		public long UniqueId { get; set; }
		public DateTime ReceiveDate { get; set; }
	}

	public class EventContentDiceRaceDB
	{
		public long EventContentId { get; set; }
		public long Node { get; set; }
		public long LapCount { get; set; }
		public long DiceRollCount { get; set; }
		public long ReceiveRewardLapCount { get; set; }
	}

	public class EventContentDiceResult
	{
		public int Index { get; set; }
		public int MoveAmount { get; set; }
		public List<ParcelInfo> Rewards { get; set; }
	}

	public class EventContentFortuneGachaStackCountDB
	{
		public long EventContentId { get; set; }
		public int GachaStackCount { get; set; }
	}

	public class EventContentLocationDB
	{
		public long LocationId { get; set; }
		public long Rank { get; set; }
		public long Exp { get; set; }
		public long ScheduleCount { get; set; }
		public Dictionary<long, List<VisitingCharacterDB>> ZoneVisitCharacterDBs { get; set; }
	}

	public class EventContentPermanentDB
	{
		public long EventContentId { get; set; }
		public bool IsStageAllClear { get; set; }
		public bool IsReceivedCharacterReward { get; set; }
	}

	public class EventContentTreasureSaveBoard
	{
		public long VariationId { get; set; }
		public int Round { get; set; }
		public List<EventContentTreasureObject> TreasureObjects { get; set; }
	}

	public class EventContentTreasureObject
	{
		public long ServerId { get; set; }
		public long RewardId { get; set; }
		public int Rotation { get; set; }
		public bool IsHiddenImage { get; set; }
		public List<EventContentTreasureCell> Cells { get; set; }
	}

	public class EventContentTreasureCell : IEquatable<EventContentTreasureCell>
	{
		public int X { get; set; }
		public int Y { get; set; }
		public bool Equals(EventContentTreasureCell other)
		{
			return default;
		}

	}

	public class EventContentTreasureHistoryDB
	{
		private EventContentTreasureInfo _treasureInfo;
		private EventContentTreasureRoundInfo _treasureRoundInfo;
		public long EventContentId { get; set; }
		public int Round { get; set; }
		public EventContentTreasureBoardHistory Board { get; set; }
		public bool IsComplete { get; set; }
		public List<EventContentTreasureObject> HintTreasures { get; set; }
	
		[JsonIgnore]
		public int MetaRound { get; }
	
		[JsonIgnore]
		public bool CanComplete { get; }
	
		[JsonIgnore]
		public bool CanFlip { get; }
	
		[JsonIgnore]
		public EventContentTreasureInfo TreasureInfo { get; }
	
		[JsonIgnore]
		public EventContentTreasureRoundInfo TreasureRoundInfo { get; }
	}

	public class EventContentTreasureBoardHistory
	{
		public List<long> TreasureIds { get; set; }
		public List<EventContentTreasureCell> NormalCells { get; set; }
		public List<EventContentTreasureObject> Treasures { get; set; }
	}

	public class EventInfoDB
	{
		public long EventId { get; set; }
		public uint ImageNameHash { get; set; }
	}

	public class EventRewardIncreaseDB
	{
		public EventTargetType EventTargetType { get; set; }
		public BasisPoint Multiplier { get; set; }
		public DateTime BeginDate { get; set; }
		public DateTime EndDate { get; set; }
	}

	public class FieldStageSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class FriendDB
	{
		public long AccountId;
		public int Level;
		public string Nickname;
		public DateTime LastConnectTime;
		public long RepresentCharacterUniqueId;
		public long RepresentCharacterCostumeId;
		public long ComfortValue;
		public long FriendCount;
		public AccountAttachmentDB AttachmentDB;
	}

	public class FriendIdCardDB
	{
		public int Level { get; set; }
		public string FriendCode { get; set; }
		public string Comment { get; set; }
		public DateTime LastConnectTime { get; set; }
		public long RepresentCharacterUniqueId { get; set; }
		public long RepresentCharacterCostumeId { get; set; }
		public bool SearchPermission { get; set; }
		public bool AutoAcceptFriendRequest { get; set; }
		public long CardBackgroundId { get; set; }
		public bool ShowAccountLevel { get; set; }
		public bool ShowFriendCode { get; set; }
		public bool ShowRaidRanking { get; set; }
		public bool ShowArenaRanking { get; set; }
		public bool ShowEliminateRaidRanking { get; set; }
		public Nullable<long> ArenaRanking { get; set; }
		public Nullable<long> RaidRanking { get; set; }
		public Nullable<int> RaidTier { get; set; }
		public Nullable<long> EliminateRaidRanking { get; set; }
		public Nullable<int> EliminateRaidTier { get; set; }
		public long EmblemId { get; set; }
	}

	public class GachaLogDB
	{
		public long CharacterId { get; set; }
	}

	public class GuideMissionSeasonDB : IMemoryPackable<GuideMissionSeasonDB>, IMemoryPackFormatterRegister
	{
		public long SeasonId { get; set; }
		public long LoginCount { get; set; }
		public DateTime StartDate { get; set; }
		public DateTime LoginDate { get; set; }
		public bool IsComplete { get; set; }
		public bool IsFinalMissionComplete { get; set; }
		public Nullable<DateTime> CollectionItemReceiveDate { get; set; }
	}

	public class IdCardBackgroundDB : ParcelBase
	{
		public override ParcelType Type { get; }
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public override IEnumerable<ParcelInfo> ParcelInfos { get; }
	}

	public enum IssueAlertTypeCode
	{
		All = 1,
		File_Target = 2,
		AllButFile_Exception = 3,
	}

	public class IssueAlertInfoDB
	{
		public int IssueAlertId { get; set; }
		public IssueAlertTypeCode IssueAlertType { get; set; }
		public DateTime StartDate { get; set; }
		public DateTime EndDate { get; set; }
		public byte DisplayOrder { get; set; }
		public int PublishId { get; set; }
		public string Url { get; set; }
		public string Subject { get; set; }
	}

	public class MailDB
	{
		public long ServerId { get; set; }
		public long AccountServerId { get; set; }
		public MailType Type { get; set; }
		public long UniqueId { get; set; }
		public string Sender { get; set; }
		public string Comment { get; set; }
		public DateTime SendDate { get; set; }
		public Nullable<DateTime> ReceiptDate { get; set; }
		public Nullable<DateTime> ExpireDate { get; set; }
		public List<ParcelInfo> ParcelInfos { get; set; }
		public List<ParcelInfo> RemainParcelInfos { get; set; }
	}

	public class MiniGameDefenseStageHistoryDB
	{
		public long StageId { get; set; }
		public bool Star1Flag { get; set; }
		public bool Star2Flag { get; set; }
		public bool Star3Flag { get; set; }
		public bool FirstClearRewardReceive { get; set; }
		public bool StarRewardReceive { get; set; }
	
		[JsonIgnore]
		public bool IsThreeStar { get; }
	
		[JsonIgnore]
		public bool IsFirstClear { get; }
	}

	public class MiniGameDreamMakerInfoDB
	{
		public long EventContentId { get; set; }
		public long Round { get; set; }
		public long Multiplier { get; set; }
		public long DayOfNumber { get; set; }
		public long ActionCount { get; set; }
		public long CurrentRoundEndingId { get; set; }
		public bool EndingRewardReceived { get; set; }
		public bool CanStartNewGame { get; set; }
	
		[JsonIgnore]
		public bool CanReceiveEndingReward { get; }
	}

	public class MiniGameDreamMakerParameterDB
	{
		public DreamMakerParameterType ParameterType { get; set; }
		public long BaseAmount { get; set; }
		public long CurrentAmount { get; set; }
	}

	public class MiniGameDreamMakerEndingDB
	{
		public long EventContentId { get; set; }
		public long EndingId { get; set; }
		public long ClearCount { get; set; }
		public DateTime ClearDate { get; set; }
	}

	public class MiniGameHistoryDB
	{
		public long EventContentId { get; set; }
		public long UniqueId { get; set; }
		public long HighScore { get; set; }
		public long AccumulatedScore { get; set; }
		public DateTime ClearDate { get; set; }
		public bool IsFullCombo { get; set; }
	}

	public class MiniGameResult
	{
		public EventContentType ContentType { get; }
		public long EventContentId { get; set; }
		public long UniqueId { get; set; }
		public long TotalScore { get; set; }
		public long ComboCount { get; set; }
		public long FeverCount { get; set; }
		public bool AllCombo { get; set; }
		public long HPBonusScore { get; set; }
		public long NoteCount { get; set; }
		public long CriticalCount { get; set; }
	}

	public class MiniGameShootingHistoryDB
	{
		public long EventContentId { get; set; }
		public long UniqueId { get; set; }
		public long ArriveSection { get; set; }
		public DateTime LastUpdateDate { get; set; }
		public bool IsClearToday { get; set; }
	}

	public class MissionHistoryDB : IEquatable<MissionHistoryDB>, IMemoryPackable<MissionHistoryDB>, IMemoryPackFormatterRegister
	{
	
		[JsonIgnore]
		public long ServerId { get; set; }
	
		[JsonIgnore]
		public long AccountServerId { get; set; }
		public long MissionUniqueId { get; set; }
		public DateTime CompleteTime { get; set; }
		public bool Expired { get; set; }
		public bool Equals(MissionHistoryDB other)
		{
			return default;
		}

	}

	public class MomoTalkOutLineDB
	{
		public long CharacterDBId { get; set; }
		public long CharacterId { get; set; }
		public long LatestMessageGroupId { get; set; }
		public Nullable<long> ChosenMessageId { get; set; }
		public DateTime LastUpdateDate { get; set; }
	}

	public class MomoTalkChoiceDB
	{
		public long CharacterDBId { get; set; }
		public long MessageGroupId { get; set; }
		public long ChosenMessageId { get; set; }
		public DateTime ChosenDate { get; set; }
	}

	public class MonthlyProductPurchaseDB
	{
		public long ProductId { get; set; }
		public DateTime PurchaseDate { get; set; }
		public Nullable<DateTime> LastDailyRewardDate { get; set; }
		public Nullable<DateTime> RewardEndDate { get; set; }
		public ProductTagType ProductTagType { get; }
	}

	public class MultiFloorRaidDB
	{
		public long SeasonId { get; set; }
		public int ClearedDifficulty { get; set; }
		public DateTime LastClearDate { get; set; }
		public int RewardDifficulty { get; set; }
		public DateTime LastRewardDate { get; set; }
		public int ClearBattleFrame { get; set; }
	
		[JsonIgnore]
		public bool AllCleared { get; }
	
		[JsonIgnore]
		public bool HasReceivableRewards { get; }
	
		[JsonIgnore]
		public List<ParcelInfo> TotalReceivableRewards { get; }
	
		[JsonIgnore]
		public List<ParcelInfo> TotalReceivedRewards { get; }
	}

	public class MultiSweepPresetDB
	{
		public long PresetId { get; set; }
		public string PresetName { get; set; }
		public IEnumerable<long> StageIds { get; set; }
		public IEnumerable<ParcelKeyPair> ParcelIds { get; set; }
	}

	public class OpenConditionDB
	{
		public OpenConditionContent ContentType { get; set; }
		public bool HideWhenLocked { get; set; }
		public long AccountLevel { get; set; }
		public long ScenarioModeId { get; set; }
		public long CampaignStageUniqueId { get; set; }
		public MultipleConditionCheckType MultipleConditionCheckType { get; set; }
		public WeekDay OpenDayOfWeek { get; set; }
		public long OpenHour { get; set; }
		public WeekDay CloseDayOfWeek { get; set; }
		public long CloseHour { get; set; }
		public long CafeIdForCafeRank { get; set; }
		public long CafeRank { get; set; }
		public long OpenedCafeId { get; set; }
	}

	public class ProductPurchaseCountDB
	{
		public long EventContentId { get; set; }
		public long ShopExcelId { get; set; }
		public int PurchaseCount { get; set; }
		public DateTime LastPurchaseDate { get; set; }
		public PurchaseCountResetType PurchaseCountResetType { get; set; }
		public DateTime ResetDate { get; set; }
	}

	public class PurchaseCountDB
	{
		public long ShopCashId { get; set; }
		public int PurchaseCount { get; set; }
		public DateTime ResetDate { get; set; }
		public Nullable<DateTime> PurchaseDate { get; set; }
		public Nullable<DateTime> ManualResetDate { get; set; }
	}

	public class PurchaseOrderDB
	{
		public long ShopCashId { get; set; }
		public PurchaseStatusCode StatusCode { get; set; }
		public long PurchaseOrderId { get; set; }
	}

	public class RaidBattleDB
	{
		public ContentType ContentType { get; set; }
		public long RaidUniqueId { get; set; }
		public int RaidBossIndex { get; set; }
		public long CurrentBossHP { get; set; }
		public long CurrentBossGroggy { get; set; }
		public long CurrentBossAIPhase { get; set; }
		public string BIEchelon { get; set; }
		public bool IsClear { get; set; }
		public RaidMemberCollection RaidMembers { get; set; }
		public List<long> SubPartsHPs { get; set; }
	}

	public class RaidBossDB
	{
		public ContentType ContentType { get; set; }
		public int BossIndex { get; set; }
		public long BossCurrentHP { get; set; }
		public long BossGroggyPoint { get; set; }
	}

	public class RaidDB
	{
		public RaidMemberDescription Owner { get; set; }
		public ContentType ContentType { get; set; }
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public long SeasonId { get; set; }
		public DateTime Begin { get; set; }
		public DateTime End { get; set; }
	
		[JsonIgnore]
		public long OwnerAccountServerId { get; }
	
		[JsonIgnore]
		public string OwnerNickname { get; }
		public long PlayerCount { get; set; }
	
		[JsonIgnore]
		public string BossGroup { get; }
	
		[JsonIgnore]
		public Difficulty BossDifficulty { get; }
	
		[JsonIgnore]
		public int LastBossIndex { get; }
		public List<int> Tags { get; set; }
		public string SecretCode { get; set; }
		public RaidStatus RaidState { get; set; }
		public bool IsPractice { get; set; }
		public List<RaidBossDB> RaidBossDBs { get; set; }
		public Dictionary<long, List<long>> ParticipateCharacterServerIds { get; set; }
		public bool IsEnterRoom { get; set; }
	
		[JsonIgnore]
		public long SessionHitPoint { get; }
		public long AccountLevelWhenCreateDB { get; set; }
		public bool ClanAssistUsed { get; set; }
	}

	public abstract class RaidLobbyInfoDB
	{
		public long SeasonId { get; set; }
		public int Tier { get; set; }
		public long Ranking { get; set; }
		public long BestRankingPoint { get; set; }
		public long TotalRankingPoint { get; set; }
		public long ReceivedRankingRewardId { get; set; }
		public bool CanReceiveRankingReward { get; set; }
		public RaidDB PlayingRaidDB { get; set; }
		public List<long> ReceiveRewardIds { get; set; }
		public List<long> ReceiveLimitedRewardIds { get; set; }
		public List<long> ParticipateCharacterServerIds { get; set; }
		public Dictionary<string, Difficulty> PlayableHighestDifficulty { get; set; }
		public Dictionary<long, long> SweepPointByRaidUniqueId { get; set; }
		public DateTime SeasonStartDate { get; set; }
		public DateTime SeasonEndDate { get; set; }
		public DateTime SettlementEndDate { get; set; }
		public long NextSeasonId { get; set; }
		public DateTime NextSeasonStartDate { get; set; }
		public DateTime NextSeasonEndDate { get; set; }
		public DateTime NextSettlementEndDate { get; set; }
		public ClanAssistUseInfo ClanAssistUseInfo { get; set; }
		public Dictionary<int, bool> RemainFailCompensation { get; set; }
	}

	public class SingleRaidLobbyInfoDB : RaidLobbyInfoDB
	{
	}

	public class EliminateRaidLobbyInfoDB : RaidLobbyInfoDB
	{
		public List<string> OpenedBossGroups { get; set; }
		public Dictionary<string, long> BestRankingPointPerBossGroup { get; set; }
	}

	public class RaidGiveUpDB
	{
		public long Ranking { get; set; }
		public long RankingPoint { get; set; }
		public long BestRankingPoint { get; set; }
	}

	public abstract class RaidUserDB : ICloneable
	{
		public long AccountId { get; set; }
		public long RepresentCharacterUniqueId { get; set; }
		public long RepresentCharacterCostumeId { get; set; }
		public long Level { get; set; }
		public string Nickname { get; set; }
		public int Tier { get; set; }
		public long Rank { get; set; }
		public long BestRankingPoint { get; set; }
		public double BestRankingPointDetail { get; set; }
		public AccountAttachmentDB AccountAttachmentDB { get; set; }
		public object Clone()
		{
			return default;
		}

	}

	public class SingleRaidUserDB : RaidUserDB
	{
		public RaidTeamSettingDB RaidTeamSettingDB { get; set; }
	}

	public class EliminateRaidUserDB : RaidUserDB
	{
		public Dictionary<string, long> BossGroupToRankingPoint;
	}

	public class RaidTeamSettingDB
	{
		public long AccountId { get; set; }
		public long TryNumber { get; set; }
		public EchelonType EchelonType { get; set; }
		public EchelonExtensionType EchelonExtensionType { get; set; }
		public IList<RaidCharacterDB> MainCharacterDBs { get; set; }
		public IList<RaidCharacterDB> SupportCharacterDBs { get; set; }
		public IList<long> SkillCardMulliganCharacterIds { get; set; }
		public long TSSInteractionUniqueId { get; set; }
		public long LeaderCharacterUniqueId { get; set; }
	}

	public class EliminateRaidAdditionalRankingInfo
	{
		public Dictionary<string, long> BossGroupToScore;
	}

	public class RaidCharacterDB
	{
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public int StarGrade { get; set; }
		public int Level { get; set; }
		public int SlotIndex { get; set; }
		public long AccountId { get; set; }
		public bool IsAssist { get; set; }
		public bool HasWeapon { get; set; }
		public int WeaponStarGrade { get; set; }
		public long CostumeId { get; set; }
		public int CombatStyleIndex { get; set; }
	}

	public class RaidRankingInfo
	{
		public long SeasonId { get; set; }
		public long AccountId { get; set; }
		public long Ranking { get; set; }
		public long Score { get; set; }
		public double ScoreDetail { get; set; }
	}

	public class RaidDetailDB
	{
		public long RaidUniqueId { get; set; }
		public DateTime EndDate { get; set; }
		public List<RaidPlayerInfoDB> DamageTable { get; set; }
	}

	public class RaidLimitedRewardHistoryDB
	{
		public ContentType ContentType { get; set; }
		public long SeasonId { get; set; }
		public long RewardId { get; set; }
		public DateTime ReceiveDate { get; set; }
	}

	public class RaidParticipateCharactersDB
	{
		public long RaidServerId { get; set; }
		public long AccountServerId { get; set; }
		public List<long> ParticipateCharacterServerIds { get; set; }
	}

	public class RaidPlayerInfoDB
	{
		public long RaidServerId { get; set; }
		public long AccountId { get; set; }
		public DateTime JoinDate { get; set; }
		public long DamageAmount { get; set; }
		public int RaidEndRewardFlag { get; set; }
		public int RaidPlayCount { get; set; }
		public string Nickname { get; set; }
		public long CharacterId { get; set; }
		public long CostumeId { get; set; }
		public Nullable<long> AccountLevel { get; set; }
	}

	public class RaidSeasonHistoryDB
	{
		public long SeasonServerId { get; set; }
		public DateTime ReceiveDateTime { get; set; }
		public long SeasonRewardGauage { get; set; }
	}

	public class RaidSeasonManageDB
	{
		public long SeasonId { get; set; }
		public DateTime SeasonStartDate { get; set; }
		public DateTime SeasonEndDate { get; set; }
		public DateTime SeasonSettlementEndDate { get; set; }
		public DateTime UpdateDate { get; set; }
	}

	public class RaidSeasonPointRewardHistoryDB
	{
		public ContentType ContentType { get; set; }
		public long SeasonId { get; set; }
		public long LastReceivedSeasonRewardId { get; set; }
		public DateTime SeasonRewardReceiveDate { get; set; }
	}

	public class RaidSeasonRankingHistoryDB
	{
		public ContentType ContentType { get; set; }
		public long AccountId { get; set; }
		public long SeasonId { get; set; }
		public long Ranking { get; set; }
		public long BestRankingPoint { get; set; }
		public int Tier { get; set; }
		public DateTime ReceivedDate { get; set; }
	}

	public struct ResetableContentId : IEquatable<ResetableContentId>
	{
		public ResetContentType Type { get; set; }
		public long Mapped { get; set; }
		public bool Equals(ResetableContentId other)
		{
			return default;
		}

	}

	public class ResetableContentValueDB : IEquatable<ResetableContentValueDB>
	{
		public ResetableContentId ResetableContentId { get; set; }
		public long ContentValue { get; set; }
		public DateTime LastUpdateTime { get; set; }
		public bool Equals(ResetableContentValueDB other)
		{
			return default;
		}

	}

	public class ScenarioCollectionDB
	{
		public long GroupId { get; set; }
		public long UniqueId { get; set; }
		public DateTime ReceiveDate { get; set; }
	}

	public class ScenarioGroupHistoryDB
	{
		public long AccountServerId { get; set; }
		public long ScenarioGroupUqniueId { get; set; }
		public long ScenarioType { get; set; }
		public Nullable<long> EventContentId { get; set; }
		public DateTime ClearDateTime { get; set; }
		public bool IsReturn { get; set; }
	}

	public sealed class SchoolDungeonStageHistoryDB
	{
		public long StageUniqueId { get; set; }
	
		[JsonIgnore]
		public long BestStarRecord { get; }
		public bool[] StarFlags { get; set; }
	
		[JsonIgnore]
		public bool Star1Flag { get; }
	
		[JsonIgnore]
		public bool Star2Flag { get; }
	
		[JsonIgnore]
		public bool Star3Flag { get; }
	
		[JsonIgnore]
		public bool IsClearedEver { get; }
	}

	public class SchoolDungeonStageSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class SelectGachaSnapshotDB
	{
		public long ShopUniqueId { get; set; }
		public long LastIndex { get; set; }
		public List<long> LastResults { get; set; }
		public Nullable<long> SavedIndex { get; set; }
		public List<long> SavedResults { get; set; }
		public Nullable<long> PickedIndex { get; set; }
	}

	public class SessionDB
	{
		public SessionKey SessionKey { get; set; }
		public DateTime LastConnect { get; set; }
		public int ConnectionTime { get; set; }
	}

	public class ShopEligmaHistoryDB
	{
		public long CharacterUniqueId { get; set; }
		public long PurchaseCount { get; set; }
	}

	public class ShopFreeRecruitHistoryDB
	{
		public long UniqueId { get; set; }
		public int RecruitCount { get; set; }
		public DateTime LastUpdateDate { get; set; }
	}

	public enum ShopProductType
	{
		None = 0,
		General = 1,
		Refresh = 2,
	}

	public class ShopInfoDB
	{
		public long EventContentId { get; set; }
		public ShopCategoryType Category { get; set; }
		public Nullable<long> ManualRefreshCount { get; set; }
		public bool IsRefresh { get; set; }
		public Nullable<DateTime> NextAutoRefreshDate { get; set; }
		public Nullable<DateTime> LastAutoRefreshDate { get; set; }
		public List<ShopProductDB> ShopProductList { get; set; }
	}

	public class ShopProductDB
	{
		public long EventContentId { get; set; }
		public long ShopExcelId { get; set; }
		public ShopCategoryType Category { get; set; }
		public long DisplayOrder { get; set; }
		public long PurchaseCount { get; set; }
	
		[JsonIgnore]
		public bool SoldOut { get; }
		public long PurchaseCountLimit { get; set; }
		public long Price { get; set; }
		public ShopProductType ProductType { get; set; }
	}

	public class ShopRecruitDB
	{
		public long Id { get; set; }
		public DateTime SalesStartDate { get; set; }
		public DateTime SalesEndDate { get; set; }
		public DateTime UpdateDate { get; set; }
	}

	public class SkipHistoryDB
	{
		public int Prologue { get; set; }
		public Dictionary<int, int> Tutorial { get; set; }
	}

	public class StickerBookDB
	{
		public long AccountId { get; set; }
		public IEnumerable<StickerDB> UnusedStickerDBs { get; set; }
		public IEnumerable<StickerDB> UsedStickerDBs { get; set; }
	}

	public class StickerDB : ParcelBase, IEquatable<StickerDB>
	{
		public override ParcelType Type { get; }
		public long StickerUniqueId { get; set; }
		public override IEnumerable<ParcelInfo> ParcelInfos { get; }
		public bool Equals(StickerDB other)
		{
			return default;
		}

	}

	public class StoryStrategyStageSaveDB : CampaignMainStageSaveDB
	{
		public override ContentType ContentType { get; }
	}

	public class StrategyObjectHistoryDB
	{
		public long StrategyObjectId { get; set; }
	}

	public class TimeAttackDungeonCharacterDB
	{
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public long CostumeId { get; set; }
		public int StarGrade { get; set; }
		public int Level { get; set; }
		public bool HasWeapon { get; set; }
		public WeaponDB WeaponDB { get; set; }
		public bool IsAssist { get; set; }
		public int CombatStyleIndex { get; set; }
	}

	public class TimeAttackDungeonBattleHistoryDB
	{
		public TimeAttackDungeonType DungeonType { get; set; }
		public long GeasId { get; set; }
		public long DefaultPoint { get; set; }
		public long ClearTimePoint { get; set; }
		public long EndFrame { get; set; }
	
		[JsonIgnore]
		public long TotalPoint { get; }
		public List<TimeAttackDungeonCharacterDB> MainCharacterDBs { get; set; }
		public List<TimeAttackDungeonCharacterDB> SupportCharacterDBs { get; set; }
	}

	public class TimeAttackDungeonRewardHistoryDB
	{
		public DateTime Date { get; set; }
		public TimeAttackDungeonRoomDB RoomDB { get; set; }
		public bool IsSweep { get; set; }
	}

	public class TimeAttackDungeonRoomDB
	{
		public long AccountId { get; set; }
		public long SeasonId { get; set; }
		public long RoomId { get; set; }
		public DateTime CreateDate { get; set; }
		public DateTime RewardDate { get; set; }
		public bool IsPractice { get; set; }
		public List<DateTime> SweepHistoryDates { get; set; }
		public List<TimeAttackDungeonBattleHistoryDB> BattleHistoryDBs { get; set; }
	
		[JsonIgnore]
		public int PlayCount { get; }
	
		[JsonIgnore]
		public long TotalPointSum { get; }
	
		[JsonIgnore]
		public bool IsRewardReceived { get; }
	
		[JsonIgnore]
		public bool IsOpened { get; }
	
		[JsonIgnore]
		public bool CanUseAssist { get; }
	
		[JsonIgnore]
		public bool IsPlayCountOver { get; }
	}

	public class ToastDB
	{
		public long UniqueId { get; set; }
		public string Text { get; set; }
		public string ToastId { get; set; }
		public DateTime BeginDate { get; set; }
		public DateTime EndDate { get; set; }
		public int LifeTime { get; set; }
		public int Delay { get; set; }
	}

	public class VisitingCharacterDB
	{
		public long UniqueId { get; set; }
		public long ServerId { get; set; }
	}

	public class WeekDungeonSaveDB : ContentSaveDB
	{
		public override ContentType ContentType { get; }
		public WeekDungeonType WeekDungeonType { get; set; }
		public int Seed { get; set; }
		public int Sequence { get; set; }
	}

	public class WeekDungeonStageHistoryDB
	{
		public long AccountServerId { get; set; }
		public long StageUniqueId { get; set; }
		public Dictionary<StarGoalType, long> StarGoalRecord { get; set; }
	
		[JsonIgnore]
		public bool IsCleardEver { get; }
	}

	public class WorldRaidSnapshot
	{
		public List<WorldRaidLocalBossDB> WorldRaidLocalBossDBs { get; set; }
		public List<WorldRaidClearHistoryDB> WorldRaidClearHistoryDBs { get; set; }
	}

	public class WorldRaidLocalBossDB
	{
		public long SeasonId { get; set; }
		public long GroupId { get; set; }
		public long UniqueId { get; set; }
		public bool IsScenario { get; set; }
		public bool IsCleardEver { get; set; }
		public long TacticMscSum { get; set; }
		public RaidBattleDB RaidBattleDB { get; set; }
		public bool IsContinue { get; }
	}

	public class WorldRaidWorldBossDB
	{
		public long GroupId { get; set; }
		public long HP { get; set; }
		public long Participants { get; set; }
	}

	public class WorldRaidClearHistoryDB
	{
		public long SeasonId { get; set; }
		public long GroupId { get; set; }
		public DateTime RewardReceiveDate { get; set; }
	}

	public class WorldRaidBossListInfoDB
	{
		public long GroupId { get; set; }
		public WorldRaidWorldBossDB WorldBossDB { get; set; }
		public List<WorldRaidLocalBossDB> LocalBossDBs { get; set; }
	}

	public class WorldRaidBossGroup : ContentsValueChangeDB
	{
		public override ContentsChangeType ContentsChangeType { get; }
		public long GroupId { get; set; }
		public DateTime BossSpawnTime { get; set; }
		public DateTime EliminateTime { get; set; }
	}

	public class WorldRaidBossDamageRatio : ContentsValueChangeDB
	{
		public override ContentsChangeType ContentsChangeType { get; }
		public BasisPoint DamageRatio { get; set; }
	}

	public enum OpenConditionLockReason
	{
		None = 0,
		Level = 1,
		StageClear = 2,
		Time = 4,
		Day = 8,
		CafeRank = 16,
		ScenarioModeClear = 32,
		CafeOpen = 64,
	}

	public class ParcelResultDB
	{
		public AccountDB AccountDB { get; set; }
		public List<AcademyLocationDB> AcademyLocationDBs { get; set; }
		public AccountCurrencyDB AccountCurrencyDB { get; set; }
		public List<CharacterDB> CharacterDBs { get; set; }
		public List<WeaponDB> WeaponDBs { get; set; }
		public List<CostumeDB> CostumeDBs { get; set; }
		public List<CharacterDB> TSSCharacterDBs { get; set; }
		public Dictionary<long, EquipmentDB> EquipmentDBs { get; set; }
		public List<long> RemovedEquipmentIds { get; set; }
		public Dictionary<long, ItemDB> ItemDBs { get; set; }
		public List<long> RemovedItemIds { get; set; }
		public Dictionary<long, FurnitureDB> FurnitureDBs { get; set; }
		public List<long> RemovedFurnitureIds { get; set; }
		public Dictionary<long, IdCardBackgroundDB> IdCardBackgroundDBs { get; set; }
		public List<EmblemDB> EmblemDBs { get; set; }
		public List<StickerDB> StickerDBs { get; set; }
		public List<MemoryLobbyDB> MemoryLobbyDBs { get; set; }
		public List<long> CharacterNewUniqueIds { get; set; }
		public Dictionary<long, int> SecretStoneCharacterIdAndCounts { get; set; }
		public List<ParcelInfo> DisplaySequence { get; set; }
		public List<ParcelInfo> ParcelForMission { get; set; }
		public List<ParcelResultStepInfo> ParcelResultStepInfoList { get; set; }
		public long BaseAccountExp { get; set; }
		public long AdditionalAccountExp { get; set; }
		public long NewbieBoostAccountExp { get; set; }
	
		[JsonIgnore]
		public List<long> GachaResultCharacters { get; set; }
	}

	public class ParcelInfo : IEquatable<ParcelInfo>
	{
		public ParcelKeyPair Key { get; set; }
		public long Amount { get; set; }
		public BasisPoint Multiplier { get; set; }
	
		[JsonIgnore]
		public long MultipliedAmount { get; }
		public BasisPoint Probability { get; set; }
		public bool Equals(ParcelInfo other)
		{
			return default;
		}

	}

	public class AttendanceBookReward
	{
		public long UniqueId { get; set; }
		public AttendanceType Type { get; set; }
		public AccountState AccountType { get; set; }
		public long DisplayOrder { get; set; }
		public long AccountLevelLimit { get; set; }
		public string Title { get; set; }
		public string TitleImagePath { get; set; }
		public AttendanceCountRule CountRule { get; set; }
		public AttendanceResetType CountReset { get; set; }
		public long BookSize { get; set; }
		public DateTime StartDate { get; set; }
		public DateTime StartableEndDate { get; set; }
		public DateTime EndDate { get; set; }
		public long ExpiryDate { get; set; }
		public MailType MailType { get; set; }
		public Dictionary<long, string> DailyRewardIcons { get; set; }
		public Dictionary<long, List<ParcelInfo>> DailyRewards { get; set; }
	}

	[Serializable]
	public struct HexLocation : IEquatable<HexLocation>
	{
		public int x;
		public int y;
		public int z;
		[JsonIgnore]
		public static readonly int NeighborCount;
		[JsonIgnore]
		public static readonly HexLocation[] Directions;
	
		[JsonIgnore]
		public static HexLocation Zero { get; }
	
		[JsonIgnore]
		public static HexLocation Invalid { get; }
		public bool Equals(HexLocation other)
		{
			return default;
		}

	}

	public class Strategy
	{
		public long EntityId;
		public Vector3 Rotate;
		public long Id;
		public HexLocation Location;
		[JsonIgnore]
		public CampaignStrategyObjectExcel CampaignStrategyExcel;
		public bool PlayAnimation { get; set; }
		public bool Activated { get; set; }
		public List<int> Values { get; set; }
		public int Index { get; set; }
	
		[JsonIgnore]
		public bool Movable { get; }
	
		[JsonIgnore]
		public bool NeedValueType { get; }
	}

	public class BattleSummary : IEquatable<BattleSummary>
	{
		[JsonIgnore]
		private int writeFrame;
		[JsonIgnore]
		private Battle battle;
		public long HashKey { get; set; }
		public bool IsBossBattle { get; set; }
		public BattleTypes BattleType { get; set; }
		public long StageId { get; set; }
		public long GroundId { get; set; }
		public string Winner { get; set; }
	
		[JsonIgnore]
		public bool IsPlayerWin { get; }
		public BattleEndType EndType { get; set; }
		public int EndFrame { get; set; }
		//public GroupSummary Group01Summary { get; set; }
		//public GroupSummary Group02Summary { get; set; }
		public WeekDungeonSummary WeekDungeonSummary { get; set; }
		public RaidSummary RaidSummary { get; set; }
		public ArenaSummary ArenaSummary { get; set; }
	
		[JsonIgnore]
		public TimeSpan EndTime { get; }
		public int ContinueCount { get; set; }
		public float ElapsedRealtime { get; set; }
	
		[JsonIgnore]
		public string FindGiftClearText { get; }
	
		[JsonIgnore]
		public long EventContentId { get; set; }
	
		[JsonIgnore]
		public long FixedEchelonId { get; set; }
		public bool IsAbort { get; set; }
		public bool IsDefeatBattle { get; set; }
	
		[JsonIgnore]
		public bool IsDefeatFailure { get; }
		public bool Equals(BattleSummary other)
		{
			return default;
		}

	}

	public class SkillCardHand
	{
		public float Cost { get; set; }
		public List<SkillCardInfo> SkillCardsInHand { get; set; }
	}

	public class TacticSkipSummary
	{
		public long StageId { get; set; }
		public long Group01HexaUnitId { get; set; }
		public long Group02HexaUnitId { get; set; }
	}

	public class HexaUnit
	{
		public long EntityId;
		public Dictionary<long, long> HpInfos;
		public Dictionary<long, long> DyingInfos;
		public Dictionary<long, int> BuffInfos;
		public int ActionCountMax;
		public int ActionCount;
		public int Mobility;
		public int StrategySightRange;
		public long Id;
		public Vector3 Rotate;
		public HexLocation Location;
		public HexLocation AIDestination;
		public bool IsActionComplete;
		public bool IsPlayer;
		public bool IsFixedEchelon;
		public int MovementOrder;
		public Dictionary<TacticEntityType, List<ParcelInfo>> RewardParcelInfosWithDropTacticEntityType;
		[JsonIgnore]
		public CampaignUnitExcel CampaignUnitExcel;
		[JsonIgnore]
		public List<HexaTile> MovableTiles;
		[JsonIgnore]
		public List<List<HexaTile>> MovementMap;
	
		[JsonIgnore]
		public List<string> BuffGroupIds { get; }
		public SkillCardHand SkillCardHand { get; set; }
		public bool PlayAnimation { get; set; }
	
		[JsonIgnore]
		public Dictionary<TacticEntityType, List<long>> RewardItems { get; }
	}

	public enum SkillSlot
	{
		None = 0,
		NormalAttack01 = 1,
		NormalAttack02 = 2,
		NormalAttack03 = 3,
		NormalAttack04 = 4,
		NormalAttack05 = 5,
		NormalAttack06 = 6,
		NormalAttack07 = 7,
		NormalAttack08 = 8,
		NormalAttack09 = 9,
		NormalAttack10 = 10,
		ExSkill01 = 11,
		ExSkill02 = 12,
		ExSkill03 = 13,
		ExSkill04 = 14,
		ExSkill05 = 15,
		ExSkill06 = 16,
		ExSkill07 = 17,
		ExSkill08 = 18,
		ExSkill09 = 19,
		ExSkill10 = 20,
		Passive01 = 21,
		Passive02 = 22,
		Passive03 = 23,
		Passive04 = 24,
		Passive05 = 25,
		Passive06 = 26,
		Passive07 = 27,
		Passive08 = 28,
		Passive09 = 29,
		Passive10 = 30,
		ExtraPassive01 = 31,
		ExtraPassive02 = 32,
		ExtraPassive03 = 33,
		ExtraPassive04 = 34,
		ExtraPassive05 = 35,
		ExtraPassive06 = 36,
		ExtraPassive07 = 37,
		ExtraPassive08 = 38,
		ExtraPassive09 = 39,
		ExtraPassive10 = 40,
		Support01 = 41,
		Support02 = 42,
		Support03 = 43,
		Support04 = 44,
		Support05 = 45,
		Support06 = 46,
		Support07 = 47,
		Support08 = 48,
		Support09 = 49,
		Support10 = 50,
		EnterBattleGround = 51,
		LeaderSkill01 = 52,
		LeaderSkill02 = 53,
		LeaderSkill03 = 54,
		LeaderSkill04 = 55,
		LeaderSkill05 = 56,
		LeaderSkill06 = 57,
		LeaderSkill07 = 58,
		LeaderSkill08 = 59,
		LeaderSkill09 = 60,
		LeaderSkill10 = 61,
		Equipment01 = 62,
		Equipment02 = 63,
		Equipment03 = 64,
		Equipment04 = 65,
		Equipment05 = 66,
		Equipment06 = 67,
		Equipment07 = 68,
		Equipment08 = 69,
		Equipment09 = 70,
		Equipment10 = 71,
		PublicSkill01 = 72,
		PublicSkill02 = 73,
		PublicSkill03 = 74,
		PublicSkill04 = 75,
		PublicSkill05 = 76,
		PublicSkill06 = 77,
		PublicSkill07 = 78,
		PublicSkill08 = 79,
		PublicSkill09 = 80,
		PublicSkill10 = 81,
		GroupBuff01 = 82,
		HexaBuff01 = 83,
		EventBuff01 = 84,
		EventBuff02 = 85,
		EventBuff03 = 86,
		MoveAttack01 = 87,
		MetamorphNormalAttack = 88,
		GroundPassive01 = 89,
		GroundPassive02 = 90,
		GroundPassive03 = 91,
		GroundPassive04 = 92,
		GroundPassive05 = 93,
		GroundPassive06 = 94,
		GroundPassive07 = 95,
		GroundPassive08 = 96,
		GroundPassive09 = 97,
		GroundPassive10 = 98,
		HiddenPassive01 = 99,
		HiddenPassive02 = 100,
		HiddenPassive03 = 101,
		HiddenPassive04 = 102,
		HiddenPassive05 = 103,
		HiddenPassive06 = 104,
		HiddenPassive07 = 105,
		HiddenPassive08 = 106,
		HiddenPassive09 = 107,
		HiddenPassive10 = 108,
		Count = 109,
	}

	public class ConquestDisplayInfo : IComparable
	{
		public ConquestTriggerType TriggerType { get; set; }
		public ConquestDisplayType Type { get; set; }
		public long EntityId { get; set; }
		public long TileUniqueId { get; set; }
		public string Parameter { get; set; }
		public int DisplayOrder { get; set; }
		public bool DisplayOnce { get; set; }
		public int CompareTo(object obj)
		{
			return default;
		}

	}

	public class MultiSweepParameter
	{
		public Nullable<long> EventContentId;
		public ContentType ContentType;
		public long StageId;
		public int SweepCount;
	}

	public struct ParcelKeyPair : IEquatable<ParcelKeyPair>, IComparable<ParcelKeyPair>
	{
		public static readonly ParcelKeyPair Empty;
		public ParcelType Type { get; set; }
		public long Id { get; set; }
		public bool Equals(ParcelKeyPair other)
		{
			return default;
		}

		public int CompareTo(ParcelKeyPair other)
		{
			return default;
		}

	}

	public struct RaidDamage
	{
		public static readonly RaidDamage Invalid;
		public int Index { get; set; }
		public long GivenDamage { get; set; }
		public long GivenGroggyPoint { get; set; }
	}

	public class RaidBossResultCollection : KeyedCollection<int, RaidBossResult>
	{
	
		[JsonIgnore]
		public int LastIndex { get; }
	
		[JsonIgnore]
		public long TotalDamage { get; }
	
		[JsonIgnore]
		public long CurrentDamage { get; }
	
		[JsonIgnore]
		public long TotalGroggyPoint { get; }
	
		[JsonIgnore]
		public long CurrentGroggyPoint { get; }
	
		[JsonIgnore]
		public int TotalGroggyCount { get; }
		protected override int GetKeyForItem(RaidBossResult item)
		{
			return default;
		}

	}

	public class MinigameRhythmSummary : IEquatable<MinigameRhythmSummary>
	{
		public string MusicTitle;
		public int PatternDifficulty;
		public bool IsSpecial;
		public int TotalNoteCount;
		public int CriticalCount;
		public int AttackCount;
		public int MissCount;
		public bool IsFullCombo;
		public int MaxCombo;
		public long FinalScore;
		public long HPBonusScore;
		public DateTime GameStartTime;
		public DateTime GameEndTime;
		public float RhythmGamePlayTime;
		public float StdDev;
		public MinigameJudgeRecord[] MinigameJudgeRecords;
		public bool IsAutoPlay;
		public bool Equals(MinigameRhythmSummary other)
		{
			return default;
		}

	}

	public class MiniGameShootingSummary
	{
		public long EventContentId;
		public long StageId;
		public long PlayerCharacterId;
		public List<long> GeasIds;
		public long SectionCount;
		public long ArriveSection;
		public float LeftTimeSec;
		public float ProgressedTimeSec;
		public Dictionary<long, int> KillEnemies;
		public bool IsWin;
	}

	public class TBGBoardSaveDB
	{
		private ITBGSeasonInfo _seasonInfoCache;
		[JsonIgnore]
		public bool WasHiddenTreasureRecorded;
		[JsonIgnore]
		public bool WasHiddenPotalOpenConditionRecorded;
	
		[JsonIgnore]
		public TBGEventHandler EventHandler { get; set; }
	
		[JsonIgnore]
		public ITBGSeasonInfo SeasonInfo { get; }
	
		[JsonIgnore]
		public bool HasActiveEncounter { get; }
	
		[JsonIgnore]
		public TBGHexaMapDB CurrentMap { get; }
	
		[JsonIgnore]
		public bool IsClearThema { get; }
	
		[JsonIgnore]
		public bool Sweepable { get; }
		public long AccountId { get; set; }
		public long EventContentId { get; set; }
		public int Round { get; set; }
		public int ThemaIndex { get; set; }
		public TBGThemaType CurrentThemaMapType { get; set; }
		public TBGHexaMapDB MainMap { get; set; }
		public TBGHexaMapDB HiddenMap { get; set; }
		public TBGPlayerDB Player { get; set; }
		public TBGEncounterDB Encounter { get; set; }
		public Dictionary<int, TBGThemaClearRecord> BestClearRecord { get; set; }
		public List<int> HiddenTreasureRecord { get; set; }
		public List<int> HiddenPotalOpenConditionRecord { get; set; }
	
		[JsonIgnore]
		public ParcelInfo CurrentRevivalCost { get; }
	}

	public class TBGPlayerDB
	{
		private TBGBoardSaveDB _saveDB;
		private ITBGSeasonInfo _seasonInfoCache;
		private bool _hasItemsDirty;
		private bool _hasItemEffectDirty;
	
		[JsonIgnore]
		public ITBGSeasonInfo SeasonInfo { get; }
	
		[JsonIgnore]
		public int MaxHitPoint { get; }
	
		[JsonIgnore]
		public bool IsMaxHitPointReached { get; }
	
		[JsonIgnore]
		public IReadOnlyList<ITBGDiceInfo> CurrentDiceInfo { get; }
	
		[JsonIgnore]
		public TBGItemEffectDB ActivatedDefenceEffect { get; }
	
		[JsonIgnore]
		public TBGItemEffectDB ActivatedDefenceCriticalEffect { get; }
	
		[JsonIgnore]
		public TBGItemEffectDB ActivatedGuideEffect { get; }
	
		[JsonIgnore]
		public IEnumerable<TBGItemEffectDB> ActivatedDiceAddDotEffect { get; }
	
		[JsonIgnore]
		public IEnumerable<TBGItemEffectDB> ActivatedPermanentDiceAddDotEffect { get; }
	
		[JsonIgnore]
		public bool IsMaxPermanentDiceAddDotReached { get; }
	
		[JsonIgnore]
		public TBGItemEffectDB ActivatedDiceForceDotEffect { get; }
	
		[JsonIgnore]
		public TBGItemDB[] ItemSlots { get; }
		public HexLocation Location { get; set; }
		public long EventContentId { get; set; }
		public int HitPoint { get; set; }
		public long DiceId { get; set; }
		public Dictionary<TBGProbModifyCondition, int> DiceProbModifyParams { get; set; }
		public List<TBGItemDB> Items { get; set; }
		public TBGItemDB TemporaryItem { get; set; }
	
		[JsonIgnore]
		public bool HasItemsDirty { get; set; }
		public List<TBGItemEffectDB> ItemEffects { get; set; }
	
		[JsonIgnore]
		public bool HasItemEffectDirty { get; set; }
	
		[JsonIgnore]
		public bool IsDead { get; }
	}

	public abstract class TBGEncounterDB
	{
		private ITBGEncounterInfo _encounterInfoCache;
	
		[JsonIgnore]
		public ITBGEncounterInfo EncounterInfo { get; }
	
		[JsonIgnore]
		public int EncounterRewardReceiveIndex { get; }
	
		[JsonIgnore]
		public abstract TBGEncounterState EncounterState { get; }
	
		[JsonIgnore]
		public abstract int EncounterStageCode { get; }
		public long EncounterId { get; set; }
		public long InvokerServerId { get; set; }
		public int ObjectType { get; set; }
		public bool ShouldDecreaseItemEffectCounter { get; set; }
		public Dictionary<int, long> RewardUniqueIdByIndex { get; set; }
	}

	public enum TBGDiceRollResult
	{
		Failure = 0,
		Success = 1,
		CriticalSuccess = 2,
	}

	public class MissionInfo : IMissionConstraint
	{
		public long Id { get; set; }
		public MissionCategory Category { get; set; }
		public MissionResetType ResetType { get; set; }
		public MissionToastDisplayConditionType ToastDisplayType { get; set; }
		public uint Description { get; set; }
		public bool IsVisible { get; set; }
		public bool IsLimited { get; set; }
		public DateTime StartDate { get; set; }
		public DateTime StartableEndDate { get; set; }
		public DateTime EndDate { get; set; }
		public long EndDday { get; set; }
		public AccountState AccountState { get; set; }
		public long AccountLevel { get; set; }
		public List<long> PreMissionIds { get; set; }
		public long NextMissionId { get; set; }
		public SuddenMissionContentType[] SuddenMissionContentTypes { get; set; }
		public MissionCompleteConditionType CompleteConditionType { get; set; }
		public long CompleteConditionCount { get; set; }
		public List<long> CompleteConditionParameters { get; set; }
		public string RewardIcon { get; set; }
		public List<ParcelInfo> Rewards { get; set; }
		public ContentType DateAutoRefer { get; set; }
		public string ToastImagePath { get; set; }
		public long DisplayOrder { get; set; }
		public bool HasFollowingMission { get; set; }
		public string[] Shortcuts { get; set; }
		public long ChallengeStageId { get; set; }
		public bool CanComplete(DateTime serverTime)
		{
			return default;
		}

		public bool CanReceiveReward(DateTime serverTime)
		{
			return default;
		}

	}

	public struct DebuffDescription : IEquatable<DebuffDescription>
	{
		public long AccountId { get; set; }
		public string LogicEffectTemplateId { get; set; }
		public string LogicEffectGroupId { get; set; }
		public int LogicEffectLevel { get; set; }
		public int DurationFrame { get; set; }
		public SkillSlot SkillSlot { get; set; }
		public int IssuedTimestamp { get; set; }
		public bool Equals(DebuffDescription other)
		{
			return default;
		}

	}

	public class ParcelCost
	{
		private List<ConsumableItemBaseDB> _consumableItemBaseDBs;
		public List<ParcelInfo> ParcelInfos { get; set; }
		public CurrencyTransaction Currency { get; set; }
		public List<EquipmentDB> EquipmentDBs { get; set; }
		public List<ItemDB> ItemDBs { get; set; }
		public List<FurnitureDB> FurnitureDBs { get; set; }
	
		[JsonIgnore]
		public bool HasCurrency { get; }
	
		[JsonIgnore]
		public bool HasItem { get; }
	
		[JsonIgnore]
		public bool IsEmpty { get; }
	
		[JsonIgnore]
		public IEnumerable<ConsumableItemBaseDB> ConsumableItemBaseDBs { get; }
		public ConsumeCondition ConsumeCondition { get; set; }
	}

	public class CafeCharacterDB : VisitingCharacterDB
	{
		public bool IsSummon { get; set; }
		public DateTime LastInteractTime { get; set; }
	}

	public class CafeProductionParcelInfo
	{
		public ParcelKeyPair Key { get; set; }
		public long Amount { get; set; }
	}

	public class HexaTileState
	{
		public int Id { get; set; }
		public bool IsHide { get; set; }
		public bool IsFog { get; set; }
		public bool CanNotMove { get; set; }
	}

	public class HexaDisplayInfo
	{
		public HexaDisplayType Type { get; set; }
		public long EntityId { get; set; }
		public long UniqueId { get; set; }
		public HexLocation Location { get; set; }
		public long Parameter { get; set; }
		public StrategyClearRewardInfo StageRewardInfo { get; set; }
	}

	public abstract class ParcelBase
	{
		public abstract ParcelType Type { get; }
	
		[JsonIgnore]
		public abstract IEnumerable<ParcelInfo> ParcelInfos { get; }
	}

	public enum ConquestEventObjectType
	{
		None = 0,
		UnexpectedEnemy = 1,
		TreasureBox = 2,
		Erosion = 3,
		End = 4,
	}

	public enum EchelonStatusFlag
	{
		None = 0,
		BeforeDeploy = 1,
		OnDuty = 2,
	}

	public class EventContentTreasureInfo
	{
		public long EventContentId { get; }
		public int LoopRound { get; }
		public string TitleLocalize { get; }
		public string UsePregabName { get; }
		public string TreasureBGImagePath { get; }
	}

	public class EventContentTreasureRoundInfo
	{
		public long EventContentId { get; }
		public int Round { get; }
		public long CostGoodsId { get; }
		public long CellRewardId { get; }
		public int BoardSizeX { get; }
		public int BoardSizeY { get; }
		public List<EventContentTreasureItem> Treasures { get; }
		public List<ParcelInfo> CellRewards { get; }
		public List<ParcelInfo> CellCosts { get; }
		public bool IsVisualSortUnstructed { get; set; }
		public int TreasureTotalCount { get; }
	}

	public class RaidMemberCollection : KeyedCollection<long, RaidMemberDescription>
	{
		public long TotalDamage { get; }
		public IEnumerable<RaidDamage> RaidDamages { get; }
		protected override long GetKeyForItem(RaidMemberDescription item)
		{
			return default;
		}

	}

	public class RaidMemberDescription : IEquatable<RaidMemberDescription>
	{
		public long AccountId { get; set; }
		public string AccountName { get; set; }
		public long CharacterId { get; set; }
	
		[JsonIgnore]
		public long DamageGiven { get; }
	
		[JsonIgnore]
		public long GroggyGiven { get; }
		public RaidDamageCollection DamageCollection { get; set; }
		public bool Equals(RaidMemberDescription other)
		{
			return default;
		}

	}

	public class ParcelResultStepInfo
	{
		public ParcelProcessActionType ParcelProcessActionType { get; set; }
		public List<ParcelDetail> StepParcelDetails { get; set; }
	}

	public abstract class Battle
	{
		private EventHandler<EventArgs> GroupInitialized;
		private EventHandler<GameStateEventArgs> GameStateChanged;
		private EventHandler<BattleSectionChangedEventArgs> BattleSectionChanged;
		private EventHandler<CharacterPhaseChangedEventArgs> CharacterPhaseChanged;
		private EventHandler<CharacterFormConvertedEventArgs> CharacterFormConversion;
		private EventHandler<CharacterInteractWithTSSEventArgs> CharacterInteractWithTSS;
		private EventHandler<KillEventArgs> CharacterDied;
		private EventHandler<KillEventArgs> CharacterDying;
		private EventHandler<HeroReviveEventArgs> CharacterRevived;
		private EventHandler<BattleEntitySkillTriggeredEventArgs> BattleEntitySkillTriggered;
		private EventHandler<BattleItemActivatedEventArgs> BattleItemActivated;
		private EventHandler<BattleItemRecognitionEventArgs> BattleItemRecognized;
		private EventHandler<BattleItemEffectEventArgs> BattleItemEffected;
		private EventHandler<SummonedEntityClearRequestEventArgs> SummonedEntityClearRequested;
		private EventHandler<BattleEntitySpawnedEventArgs> BattleEntitySpawned;
		private EventHandler<BattleEntityRemovedEventArgs> BattleEntityRemoved;
		private EventHandler<ObstacleEventArgs> ObstacleDestroyed;
		private EventHandler<ObstacleEventArgs> ObstacleStateChanged;
		private EventHandler<ObstacleEventArgs> ObstacleGroundNodeChanged;
		private EventHandler<EffectAreaSpawnedEventArgs> EffectAreaSpawned;
		private EventHandler<NormalAttackSpawnedEventArgs> NormalAttackSpawned;
		private EventHandler<NormalAttackHitEventArgs> NormalAttackHit;
		private EventHandler<ProjectileSpawnedEventArgs> ProjectileSpawned;
		private EventHandler<ProjectileCollidedEventArgs> ProjectileCollided;
		private EventHandler<BeamEventArgs> BeamSpawned;
		private EventHandler<AuraEventArgs> AuraSpawned;
		private EventHandler<BeamEventArgs> BeamCollided;
		private EventHandler<SkillEntityRemovedEventArgs> SkillEntityRemoved;
		private EventHandler<CharacterGroundNodeChangedEventArgs> BattleEntityNodeChanged;
		private EventHandler<DotEventArgs> DotAbilityAttached;
		private EventHandler<DotEventArgs> DotAbilityRemoved;
		private EventHandler<LogicEffectExpiredEventArgs> LogicEffectExpired;
		private EventHandler<ClearGreadeFindGiftArgs> FindGiftClearGrade;
		private EventHandler<EndFindGiftArgs> FindGiftEnded;
		private EventHandler<StartWaveArgs> WaveStarted;
		private EventHandler<EndWaveArgs> WaveEnded;
		private EventHandler<WaveEnemyClearedArgs> WaveEnemyCleared;
		private EventHandler<AllClearWaveArgs> WaveAllCleared;
		private EventHandler<RandomNumberArgs> RandomNumberCreated;
		private EventHandler<PlayerSkillCardCostAddedEventArgs> PlayerSkillCardCostAdded;
		private EventHandler<PlayerSkillCardCostRegenChangedEventArgs> PlayerSkillCardCostRegenChanged;
		private EventHandler<PlayerSkillCardUsedEventArgs> PlayerSkillCardUsed;
		private EventHandler<SkillCardRedrawedEvent> SkillCardRedrawed;
		private EventHandler StageTopographyChanged;
		private EventHandler<MovingAreaEventArgs> MovingAreaMoved;
		private EventHandler<EventArgs> EntityMovedByMovingArea;
		private EventHandler<ParticleEffectEventArgs> ParticleEffectBursted;
		private BattleLogicState state;
		public Dictionary<string, int> RandomNumbers;
		private Dictionary<int, List<ValueTuple<LogicEffect, IList<AbilityModifier>>>> delayedLogicEffects;
		public CharacterGroupTargetSideMapping TargetSideMapping;
		protected PlayerGroup playerGroup;
		private EntityCollection<EffectArea> groundEffectAreas;
		private IList<EntityId> areasToRemove;
		private EntityCollection<BattleItem> battleItems;
		private IList<EntityId> battleItemsToRemove;
		private EntityCollection<Projectile> groundProjectiles;
		private IList<EntityId> projectileToRemove;
		private EntityCollection<Beam> beams;
		private IList<EntityId> beamToRemove;
		private EntityCollection<Aura> auras;
		private IList<EntityId> auraToRemove;
		private EntityCollection<NormalAttackDeliverer> normalAttacks;
		private IList<EntityId> normalAttackToRemove;
		private EntityCollection<SpawningEntity> spawners;
		private List<EntityId> spawnersToRemove;
		private List<SpawningEntity> spawnersToAdd;
		private bool isProcessingSpawners;
		private List<GroundObstacle> groundObstacles;
		private EntityCollection<GroundObstacle> runtimeObstacles;
		private List<EntityId> obstaclesToRemove;
		private EntityCollection<BarrierObstacle> barrierObstacles;
		private List<EntityId> barrierObstaclesToRemove;
		private HashSet<Character> enemyToKill;
		private ExpirableObjectHolder<OverrideStageTopographyEffect> stageTopographyExpirableObjectHolder;
		public BattleLogicState GameState { get; set; }
		public LogicGameTime GameTime { get; set; }
		public long StartTickRealTime { get; set; }
		public int CurrentFrame { get; }
		public int CurrentGameTimeFrame { get; }
		public int MaxDurationFrame { get; set; }
		public int RemainGameTimeFrame { get; }
		public IPseudoRandomService PseudoRandom { get; set; }
		public virtual List<Character> AllActiveCharacters { get; set; }
		public List<Character> AllAliveCharacters { get; set; }
		public Dictionary<ValueTuple<EntityId, string>, List<Character>> PopulationGroups { get; set; }
		public BattleEntityIdProvider Provider { get; }
		public LogicEffectProcessor LogicEffectProcessor { get; set; }
		public BattleEventBroker EventBroker { get; set; }
		public BattleSummary BattleSummary { get; set; }
		public BattleSetting Setting { get; set; }
		public long GroundId { get; }
		public long StageId { get; }
		public bool IsBossStage { get; }
		public bool IsRaid { get; }
		public bool IsWorldRaid { get; }
		public bool IsRaidForm { get; }
		public BattleTypes BattleType { get; }
		public bool DisableRootMotion { get; }
		public StageTopography StageTopography { get; set; }
		public virtual CharacterGroup PlayerGroup { get; }
		public virtual bool IsPlayerWin { get; }
		public bool PlayerHasSurvivor { get; }
		public IList<SupportActor> PlayerSupporters { get; }
		public abstract CharacterGroup EnemyGroup { get; }
		public IList<SupportActor> EnemySupporters { get; }
		public Ground Ground { get; set; }
		public Vector2 GroundCenter { get; }
		public int GroundGridNodeLength { get; }
		public BattleCommandExecuter CommandExecuter { get; set; }
		protected BattleCommandQueue CommandQueue { get; set; }
		public GroundEntitySpawner GroundEntitySpawner { get; set; }
		private SpawnProcessor spawnProcessor { get; }
		public ICollection<EffectArea> GroundEffectAreas { get; }
		public ICollection<BattleItem> BattleItems { get; }
		public ICollection<Projectile> GroundProjectiles { get; }
		protected ICollection<Beam> Beams { get; }
		public ICollection<Aura> Auras { get; }
		protected ICollection<NormalAttackDeliverer> NormalAttacks { get; }
		public ICollection<SpawningEntity> Spawners { get; }
		public IList<GroundObstacle> GroundObstacles { get; }
		public ICollection<GroundObstacle> RuntimeObstacles { get; }
		public ICollection<BarrierObstacle> BarrierObstacles { get; }
		public int TotalEnemyCount { get; set; }
		public int RemainEnemyCount { get; set; }
		public bool ImmuneHitBeforeTimeOutEnd { get; }
		public bool HideNPCWhenBattleEnd { get; }
		public bool CoverPointOff { get; }
	}

	public enum BattleTypes
	{
		None = 0,
		Adventure = 1,
		ScenarioMode = 2,
		WeekDungeonChaserA = 4,
		WeekDungeonBlood = 8,
		WeekDungeonChaserB = 16,
		WeekDungeonChaserC = 32,
		WeekDungeonFindGift = 64,
		EventContent = 128,
		TutorialAdventure = 256,
		Profiling = 512,
		SingleRaid = 2048,
		MultiRaid = 4096,
		PracticeRaid = 8192,
		EliminateRaid = 16384,
		MultiFloorRaid = 32768,
		MinigameDefense = 1048576,
		Arena = 2097152,
		TimeAttack = 8388608,
		SchoolDungeonA = 33554432,
		SchoolDungeonB = 67108864,
		SchoolDungeonC = 134217728,
		WorldRaid = 268435456,
		Conquest = 536870912,
		FieldStory = 1073741824,
		FieldContent = -2147483648,
		PvE = -301988865,
		WeekDungeon = 124,
		SchoolDungeon = 234881024,
		Raid = 30720,
		PvP = 2097152,
		All = -1,
	}

	public enum GroupTag
	{
		None = 0,
		Group01 = 1,
		Group02 = 2,
		Group03 = 4,
		Group04 = 8,
		Group05 = 16,
		Group06 = 32,
		Group07 = 64,
		Group08 = 128,
		Group09 = 256,
		Group10 = 512,
		Group11 = 1024,
		Group12 = 2048,
		Group13 = 4096,
		Group14 = 8192,
		Group15 = 16384,
		Group16 = 32768,
	}

	public enum BattleEndType
	{
		None = 0,
		AllNearlyDead = 1,
		TimeOut = 2,
		EscortFailed = 3,
		Clear = 4,
	}

	public class GroupSummary : IEquatable<GroupSummary>
	{
		public long TeamId { get; set; }
		public EntityId LeaderEntityId { get; set; }
	
		[JsonIgnore]
		public long LeaderCharacterId { get; }
		public KeyedCollection<EntityId, HeroSummary> Heroes { get; set; }
		public KeyedCollection<EntityId, HeroSummary> Supporters { get; set; }
	
		[JsonIgnore]
		public int AliveCount { get; }
		public bool UseAutoSkill { get; set; }
		public long TSSInteractionServerId { get; set; }
		public long TSSInteractionUniqueId { get; set; }
		public Dictionary<long, AssistRelation> AssistRelations { get; set; }
	
		[JsonIgnore]
		public int StrikerMaxLevel { get; }
	
		[JsonIgnore]
		public int SupporterMaxLevel { get; }
	
		[JsonIgnore]
		public int StrikerMinLevel { get; }
	
		[JsonIgnore]
		public int SupporterMinLevel { get; }
	
		[JsonIgnore]
		public int MaxCharacterLevel { get; }
	
		[JsonIgnore]
		public int MinCharacterLevel { get; }
	
		[JsonIgnore]
		public long TotalDamageGivenApplied { get; }
		public SkillCostSummary SkillCostSummary { get; set; }
		public bool Equals(GroupSummary other)
		{
			return default;
		}

	}

	public class WeekDungeonSummary : IEquatable<WeekDungeonSummary>
	{
		public WeekDungeonType DungeonType { get; set; }
		public List<FindGiftSummary> FindGifts { get; set; }
	
		[JsonIgnore]
		public int TotalFindGiftClearCount { get; }
		public bool Equals(WeekDungeonSummary other)
		{
			return default;
		}

	}

	public class RaidSummary
	{
		public long RaidSeasonId { get; set; }
	
		[JsonIgnore]
		public long GivenDamage { get; }
	
		[JsonIgnore]
		public int TotalGroggyCount { get; }
	
		[JsonIgnore]
		public int RaidBossIndex { get; }
		public RaidBossResultCollection RaidBossResults { get; set; }
	}

	public class ArenaSummary
	{
		public long ArenaMapId { get; set; }
		public long EnemyAccountId { get; set; }
		public long EnemyAccountLevel { get; set; }
	}

	public struct SkillCardInfo
	{
		public long CharacterId { get; set; }
		public int HandIndex { get; set; }
		public string SkillId { get; set; }
		public int RemainCoolTime { get; set; }
	}

	[Serializable]
	public class HexaTile
	{
		public string ResourcePath;
		public bool IsHide;
		public bool IsFog;
		public bool CanNotMove;
		public HexLocation Location;
		public Strategy Strategy;
		public HexaUnit Unit;
		[JsonIgnore]
		public HexaUnit ChallengeUnit;
		public bool PlayAnimation { get; set; }
	
		[JsonIgnore]
		public bool IsBattleReady { get; }
	
		[JsonIgnore]
		public bool StartTile { get; }
	}

	public enum ConquestTriggerType
	{
		None = 0,
		TileConquer = 1,
		TileUpgrade = 2,
		MapEnter = 3,
		SyncState = 4,
		AcquireCalculateReward = 5,
		UnexpectedEvent = 6,
		MassErosion = 7,
		MassErosionEnd = 8,
		TileErosion = 9,
		TileErosionEnd = 10,
	}

	public enum ConquestDisplayType
	{
		None = 0,
		TileConquered = 1,
		TileUpgraded = 2,
		UnexpectedEvent = 3,
		BossOpen = 4,
		PropAnimation = 5,
		PropAnimationAndBlock = 6,
		PropAnimationHoldAndPlay = 7,
		Operator = 8,
		StepComplete = 9,
		MassErosion = 10,
		Erosion = 11,
		ErosionRemove = 12,
		CheckTileErosion = 13,
		StepOpen = 14,
		BossClear = 15,
		HideConquestUI = 16,
		ShowConquestUI = 17,
		HideHexaUI = 18,
		ShowHexaUI = 19,
		StepObjectComplete = 20,
		CameraSetting = 21,
		PlayMapEnterScenario = 22,
		ShowTileConquerReward = 23,
	}

	public struct RaidBossResult : IEquatable<RaidBossResult>
	{
		public static readonly RaidBossResult Invalid;
	
		[JsonIgnore]
		public int Index { get; }
	
		[JsonIgnore]
		public long GivenDamage { get; }
	
		[JsonIgnore]
		public long GivenGroggyPoint { get; }
		public RaidDamage RaidDamage { get; set; }
		public long EndHpRateRawValue { get; set; }
		public long GroggyRateRawValue { get; set; }
		public int GroggyCount { get; set; }
		public List<long> SubPartsHPs { get; set; }
		public long AIPhase { get; set; }
		public bool Equals(RaidBossResult other)
		{
			return default;
		}

	}

	public class MinigameJudgeRecord
	{
		public int NoteIndex;
		public float TimingError;
		public int CurrentCombo;
		public JudgeGrade JudgeGradeOfThisNote;
		public bool IsFeverOn;
	}

	public interface ITBGSeasonInfo
	{
		public abstract long EventContentId { get; }
		public abstract int ItemSlotCount { get; }
		public abstract long DefaultItemDiceId { get; }
		public abstract int DefaultEchelonHP { get; }
		public abstract int HitPointUpperLimit { get; }
		public abstract int MaxDicePlus { get; }
		public abstract List<long> EchelonSlotCharacterIds { get; }
		public abstract List<string> EchelonSlotPortraits { get; }
		public abstract ParcelInfo EchelonRevivalCost { get; }
		public abstract int EnemyBossHitPoint { get; }
		public abstract int EnemyMinionHitPoint { get; }
		public abstract int AttackDamage { get; }
		public abstract int CriticalAttackDamage { get; }
		public abstract int RoundItemSelectLimit { get; }
		public abstract int InstantClearRound { get; }
		public abstract long EventUseCostId { get; }
		public abstract ParcelType EventUseCostType { get; }
		public abstract int StartThemaIndex { get; }
		public abstract int LoopThemaIndex { get; }
		public abstract string MapImagePath { get; }
		public abstract string MapNameLocalize { get; }
	}

	public class TBGEventHandler
	{
		public Action<int[], int, TBGDiceRollResult> onPlayerDiceRolled;
		public Action<IEnumerable<ParcelInfo>> onPayCostRequired;
		public Action<IEnumerable<ParcelInfo>> onReceiveRewardAsParcel;
		public Action onPortalUsed;
	}

	public class TBGHexaMapDB
	{
		private TBGBoardSaveDB _saveDB;
		private TBGHexaMapData _mapDataCache;
	
		[JsonIgnore]
		public TBGHexaMapData MapData { get; }
		public TBGThemaType MapType { get; set; }
		public Dictionary<long, TBGHexaObjectDB> Objects { get; set; }
		public bool IsTutorial { get; set; }
	
		[JsonIgnore]
		public bool HasObjectDirty { get; }
	
		[JsonIgnore]
		public long RealTreasureObjectServerId { get; }
	}

	public class TBGThemaClearRecord
	{
		public int ThemaIndex;
		public List<ParcelInfo> SweepCosts;
	}

	public interface ITBGDiceInfo
	{
		public abstract long EventContentId { get; }
		public abstract long UniqueId { get; }
		public abstract int DiceGroup { get; }
		public abstract int DiceResult { get; }
		public abstract int Prob { get; }
		public abstract IReadOnlyDictionary<TBGProbModifyCondition, TBGProbModify> ProbModifies { get; }
	}

	public class TBGItemEffectDB : ITBGItemEffectDB
	{
		private ITBGItemInfo _itemInfoCache;
	
		[JsonIgnore]
		public virtual ITBGItemInfo ItemInfo { get; }
	
		[JsonIgnore]
		public bool IsDirty { get; set; }
	
		[JsonIgnore]
		public bool Activated { get; }
	
		[JsonIgnore]
		public virtual int Stack { get; }
		public long ItemUniqueId { get; set; }
		public TBGItemType ItemType { get; set; }
		public TBGItemEffectType EffectType { get; set; }
		public virtual int RemainEncounterCounter { get; set; }
		private int _remainEncounterCounter { get; set; }
	
		[JsonIgnore]
		public bool AddedNow { get; set; }
	}

	public class TBGItemDB
	{
	
		[JsonIgnore]
		public bool IsDirty { get; set; }
		public long UniqueId { get; set; }
	}

	public interface ITBGEncounterInfo
	{
		public abstract long EventContentId { get; }
		public abstract long UniqueId { get; }
		public abstract bool AllThema { get; }
		public abstract int ThemaId { get; }
		public abstract TBGThemaType ThemaType { get; }
		public abstract TBGObjectType ObjectType { get; }
		public abstract long OptionGroupId { get; }
		public abstract bool HasBeforeStory { get; }
		public abstract string EnemyNameLocalize { get; }
		public abstract string EnemyPrefabName { get; }
		public abstract string EncounterTitleLocalize { get; }
		public abstract string BeforeStoryLocalize { get; }
		public abstract string BeforeStoryOption1Localize { get; }
		public abstract string BeforeStoryOption2Localize { get; }
		public abstract string BeforeStoryOption3Localize { get; }
		public abstract string AllyAttackLocalize { get; }
		public abstract string EnemyAttackLocalize { get; }
		public abstract string AttackDefenceLocalize { get; }
		public abstract string ClearStoryLocalize { get; }
		public abstract string DefeatStoryLocalize { get; }
		public abstract string RunAwayStoryLocalize { get; }
		public abstract bool RewardHide { get; }
	}

	public enum TBGEncounterState
	{
		None = 0,
		Active = 1,
		Disposing = 2,
	}

	public interface IMissionConstraint
	{
	}

	public class CurrencyTransaction : ParcelBase, IEquatable<CurrencyTransaction>
	{
		private CurrencyValue currencyValue { get; }
	
		[JsonIgnore]
		public override ParcelType Type { get; }
	
		[JsonIgnore]
		public override IEnumerable<ParcelInfo> ParcelInfos { get; }
	
		[JsonIgnore]
		public IDictionary<CurrencyTypes, long> CurrencyValues { get; }
	
		[JsonIgnore]
		public CurrencyTransaction Inverse { get; }
	
		[JsonIgnore]
		public bool IsEmpty { get; }
		public long Gold { get; }
		public long Gem { get; }
		public long GemBonus { get; }
		public long GemPaid { get; }
		public long ActionPoint { get; }
		public long ArenaTicket { get; }
		public long RaidTicket { get; }
		public long WeekDungeonChaserATicket { get; }
		public long WeekDungeonChaserBTicket { get; }
		public long WeekDungeonChaserCTicket { get; }
		public long WeekDungeonFindGiftTicket { get; }
		public long WeekDungeonBloodTicket { get; }
		public long AcademyTicket { get; }
		public long SchoolDungeonATicket { get; }
		public long SchoolDungeonBTicket { get; }
		public long SchoolDungeonCTicket { get; }
		public long TimeAttackDungeonTicket { get; }
		public long MasterCoin { get; }
		public long WorldRaidTicketA { get; }
		public long WorldRaidTicketB { get; }
		public long WorldRaidTicketC { get; }
		public long ChaserTotalTicket { get; }
		public long SchoolDungeonTotalTicket { get; }
		public long EliminateTicketA { get; }
		public long EliminateTicketB { get; }
		public long EliminateTicketC { get; }
		public long EliminateTicketD { get; }
		public bool Equals(CurrencyTransaction other)
		{
			return default;
		}

	}

	public enum HexaDisplayType
	{
		None = 0,
		EndBattle = 1,
		PlayScenario = 2,
		SpawnUnitFromUniqueId = 3,
		StatBuff = 4,
		DieUnit = 5,
		HideStrategy = 6,
		SpawnUnit = 7,
		SpawnStrategy = 8,
		SpawnTile = 9,
		HideTile = 10,
		ClearFogOfWar = 11,
		MoveUnit = 12,
		WarpUnit = 13,
		SetTileMovablity = 14,
		WarpUnitFromHideTile = 15,
		BossExile = 16,
	}

	public class StrategyClearRewardInfo
	{
		public List<ParcelInfo> FirstClearReward { get; set; }
		public List<ParcelInfo> ThreeStarReward { get; set; }
		public Dictionary<long, List<ParcelInfo>> StrategyObjectRewards { get; set; }
		public ParcelResultDB ParcelResultDB { get; set; }
	
		[JsonIgnore]
		public List<ParcelInfo> ClearReward { get; set; }
	
		[JsonIgnore]
		public List<ParcelInfo> ExpReward { get; set; }
	
		[JsonIgnore]
		public List<ParcelInfo> TotalReward { get; set; }
	
		[JsonIgnore]
		public List<ParcelInfo> EventContentReward { get; set; }
		public List<ParcelInfo> EventContentBonusReward { get; set; }
		public CampaignStageHistoryDB CampaignStageHistoryDB { get; set; }
	}

	public class EventContentTreasureItem
	{
		public long RewardId { get; }
		public int Amount { get; }
		public int Width { get; }
		public int Weight { get; }
		public bool IsHiddenImage { get; }
		public bool IsSquare { get; }
	}

	public class RaidDamageCollection : KeyedCollection<int, RaidDamage>
	{
	
		[JsonIgnore]
		public int MaxIndex { get; }
	
		[JsonIgnore]
		public long TotalDamage { get; }
	
		[JsonIgnore]
		public long CurrentDamage { get; }
	
		[JsonIgnore]
		public long TotalGroggyPoint { get; }
	
		[JsonIgnore]
		public long CurrentGroggyPoint { get; }
		protected override int GetKeyForItem(RaidDamage item)
		{
			return default;
		}

	}

	public enum ParcelProcessActionType
	{
		None = 0,
		Cost = 1,
		Reward = 2,
	}

	public class ParcelDetail
	{
		public ParcelInfo OriginParcel { get; set; }
		public ParcelInfo MailSendParcel { get; set; }
		public List<ParcelInfo> ConvertedParcelInfos { get; set; }
		public ParcelChangeType ParcelChangeType { get; set; }
	}

	public class GameStateEventArgs : EventArgs
	{
		public BattleLogicState GameState { get; set; }
	}

	public class BattleSectionChangedEventArgs : EventArgs
	{
		public int SectionId { get; }
		public bool SetConditionCommandOnly { get; }
	}

	public class CharacterPhaseChangedEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
		public long PhaseID { get; set; }
	}

	public class CharacterFormConvertedEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
		public int FormIndex { get; set; }
	}

	public class CharacterInteractWithTSSEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
		public EntityId TSSEntityId { get; set; }
		public bool IsInteract { get; set; }
	}

	public class KillEventArgs : EventArgs
	{
		public int LogicFrame { get; set; }
		public EntityId KillerId { get; set; }
		public EntityId TargetId { get; set; }
	}

	public class HeroReviveEventArgs : EventArgs
	{
		public int LogicFrame { get; set; }
		public EntityId TargetId { get; set; }
		public Character Character { get; set; }
	}

	public class BattleEntitySkillTriggeredEventArgs : EventArgs
	{
		public BattleEntity Invoker { get; }
		public string SkillGroupId { get; }
		public SkillSlot SkillSlot { get; }
	}

	public class BattleItemActivatedEventArgs : EventArgs
	{
		public BattleItem BattleItem { get; set; }
	}

	public class BattleItemRecognitionEventArgs : EventArgs
	{
		public BattleItem BattleItem { get; set; }
		public BattleEntity RecognizedEntity { get; set; }
	}

	public class BattleItemEffectEventArgs : EventArgs
	{
		public BattleItem BattleItem { get; set; }
		public BattleEntity EffectedEntity { get; set; }
	}

	public class SummonedEntityClearRequestEventArgs : EventArgs
	{
		public GroupTag SummonerGroupTag { get; }
		public EntityId SummonerEntityId { get; }
		public SkillSpecification SkillSpecification { get; }
		public int Index { get; }
		public long IdToClear { get; }
		public bool IsTSS { get; set; }
	}

	public class BattleEntitySpawnedEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
		public BattleEntity Entity { get; set; }
		public CharacterGroup CharacterGroup { get; }
	}

	public class BattleEntityRemovedEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
	
		[JsonIgnore]
		public BattleEntity Entity { get; set; }
	}

	public class ObstacleEventArgs : EventArgs
	{
	
		[JsonIgnore]
		public GroundObstacle Obstacle { get; }
		public EntityId EntityId { get; }
		public bool IsDestroyed { get; }
		public bool IsNodeChangedByMovingArea { get; }
	}

	public class EffectAreaSpawnedEventArgs : EventArgs
	{
	
		[JsonIgnore]
		public EffectArea Area { get; }
		public EntityId InvokerId { get; }
		public SkillSpecification SkillSpecification { get; }
		public EntityId AreaId { get; }
	}

	public class NormalAttackSpawnedEventArgs : EventArgs
	{
		public EntityId InvokerId { get; }
		public SkillSpecification SkillSpecification { get; }
		public EntityId ProjectileId { get; }
		public EntityId TargetId { get; }
		public int TargetDelay { get; }
		public string SkillEntityName { get; }
	}

	public class NormalAttackHitEventArgs : EventArgs
	{
		public EntityId ProjectileId { get; }
		public Vector2 HitPosition { get; }
		public EntityId AttackerId { get; }
	}

	public class ProjectileSpawnedEventArgs : EventArgs
	{
	
		[JsonIgnore]
		public Projectile Projectile { get; }
		public int FramePerSecond { get; }
		public EntityId InvokerId { get; }
		public SkillSpecification SkillSpecification { get; }
		public EntityId ProjectileId { get; }
		public EntityId TargetId { get; }
	}

	public class ProjectileCollidedEventArgs : EventArgs
	{
		public EntityId InvokerId { get; }
		public EntityId TargetId { get; }
		public EntityId ObstacleId { get; }
		public SkillSpecification SkillSpecification { get; }
		public EntityId ProjectileId { get; }
	}

	public class BeamEventArgs : EventArgs
	{
		public EntityId InvokerId { get; }
		public EntityId BeamId { get; }
		public EntityId HitEntityId { get; }
		public EntityId TargetId { get; }
		public Vector2 TargetPosition { get; }
		public SkillSpecification SkillSpecification { get; }
		public string SkillEntityName { get; }
	}

	public class AuraEventArgs : EventArgs
	{
		public EntityId InvokerId { get; }
		public EntityId AuraId { get; }
		public EntityId HitEntityId { get; }
		public EntityId TargetId { get; }
		public Vector2 TargetPosition { get; }
		public SkillSpecification SkillSpecification { get; }
		public string SkillEntityName { get; }
		public Aura Aura { get; }
	}

	public class SkillEntityRemovedEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
	}

	public class CharacterGroundNodeChangedEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
		public Character Character { get; set; }
		public int PreviousX { get; set; }
		public int PreviousY { get; set; }
	}

	public class DotEventArgs : EventArgs
	{
		public EntityId AttackerId { get; set; }
		public EntityId TargetId { get; set; }
		public SkillSpecification SkillSpecification { get; set; }
		public string SkillEntityName { get; set; }
		public int Channel { get; set; }
		public Hash64 TemplateIdHash { get; set; }
		public SkillSlot SkillSlot { get; set; }
		public DotAbility Invoker { get; set; }
	}

	public class LogicEffectExpiredEventArgs : EventArgs, IEquatable<LogicEffectExpiredEventArgs>
	{
		public Type TypeOfLogicEffect { get; set; }
		public EntityId AttackerId { get; set; }
		public EntityId TargetId { get; set; }
		public SkillSpecification SkillSpecification { get; set; }
		public int Channel { get; set; }
		public string LogicEffectGroupId { get; }
		public string SkillEntityName { get; set; }
		public string TemplateId { get; }
		public SkillType SkillType { get; }
		public LogicEffectCategory Category { get; }
		public bool Equals(LogicEffectExpiredEventArgs other)
		{
			return default;
		}

	}

	public class ClearGreadeFindGiftArgs : EventArgs
	{
		public string UniqueName;
		public int ClearCount { get; set; }
	}

	public class EndFindGiftArgs : EventArgs
	{
		public string UniqueName;
		public int ClearCount { get; set; }
	}

	public class StartWaveArgs : EventArgs
	{
		public string UniqueName;
		public int Step { get; set; }
	}

	public class EndWaveArgs : EventArgs
	{
		public string UniqueName;
		public int Step { get; set; }
	}

	public class WaveEnemyClearedArgs : EventArgs
	{
		public string UniqueName;
		public int Step { get; set; }
	}

	public class AllClearWaveArgs : EventArgs
	{
		public string UniqueName;
		public int Step { get; set; }
	}

	public class RandomNumberArgs : EventArgs
	{
		public string EntityConditionId { get; }
		public int RandomNumber { get; }
	}

	public class PlayerSkillCardCostAddedEventArgs : EventArgs
	{
		public GroupTag GroupTag { get; }
		public float Cost { get; }
	}

	public class PlayerSkillCardCostRegenChangedEventArgs : EventArgs
	{
		public GroupTag GroupTag { get; }
		public float CostRegen { get; }
	}

	public class PlayerSkillCardUsedEventArgs : EventArgs
	{
		public GroupTag GroupTag { get; }
		public long CharacterId { get; }
		public float Cost { get; }
		public string GroupId { get; }
		public int Level { get; }
		public BattleEntity Owner { get; }
	}

	public class SkillCardRedrawedEvent : EventArgs
	{
		public SkillCard SkillCard { get; }
	}

	public class MovingAreaEventArgs : EventArgs
	{
		public Vector2 PreviousCenter { get; }
		public Vector2 NewCenter { get; }
		public float AngleDeltaInDegree { get; }
		public float HeightDelta { get; }
		public bool KeepCameraRailPointDirectionUnchanged { get; }
		public List<Shape> PreviousWalkableMovingAreaList { get; }
	}

	public class ParticleEffectEventArgs : EventArgs
	{
		public EntityId InvokerId { get; }
		public SkillSpecification SkillSpecification { get; set; }
		public Vector3 Position { get; set; }
		public Vector3 Direction { get; set; }
		public string ParticleEffectName { get; set; }
		public List<ICustomParticleEvent> CustomParticleEvents { get; set; }
	}

	public enum BattleLogicState
	{
		None = 0,
		Preparing = 1,
		InProgress = 2,
		Finished = 3,
		Paused = 4,
	}

	public abstract class LogicEffect : IDispellable
	{
		private readonly string templateId;
		public readonly Hash64 TemplateIdHash;
		protected ResolvePriority priority;
		public SkillSpecification SkillSpecification { get; set; }
		public LogicEffectHitSpecification LogicEffectHitSpecification { get; set; }
		public BattleEntity Invoker { get; }
		public EntityId InvokerEntityId { get; }
		public BattleEntity Target { get; }
		protected EntityId TargetEntityId { get; }
		public BattleEntity OriginalTarget { get; }
		public Func<bool> ExpirationCheck { get; set; }
		public Entity ExpirationCheckOwner { get; set; }
		public string SkillEntityName { get; }
		public long SpawnRate { get; }
		public virtual string LogicEffectGroupId { get; }
		public virtual LogicEffectCategory Category { get; }
		public virtual string TemplateId { get; }
		public int Channel { get; }
		public BasisPoint ApplyRate { get; }
		public uint CommonVisualIdHash { get; }
		public Vector2 HitPosition { get; set; }
		public Vector2 BulletPosition { get; set; }
		public Vector2 BulletDirection { get; set; }
		public Entity BulletEntity { get; set; }
	
		[JsonIgnore]
		public ResolvePriority ResolvePriority { get; }
		public int Priority { get; }
	
		[JsonIgnore]
		public int ResolveIndex { get; set; }
	
		[JsonIgnore]
		public int DotIndex { get; set; }
		public int ExtraCostUsed { get; }
		public virtual bool IsDurationChangedByStat { get; }
		public bool ForceFloaterHide { get; set; }
	}

	public abstract class AbilityModifier
	{
	}

	public class CharacterGroupTargetSideMapping
	{
		private readonly Dictionary<GroupTag, GroupTag> allyTable;
		private readonly Dictionary<GroupTag, GroupTag> enemyTable;
		public GroupTag GroupTagForPlayerSideInObstacle { get; set; }
	}

	public class PlayerGroup : CharacterGroup
	{
		private ManualSkillProcessor manualSkillProcessor;
		public int EchelonNumber { get; set; }
		public PlayerSkillCardManager PlayerSkillCardManager { get; set; }
		public IList<string> HexaBuffs { get; }
	}

	public abstract class EffectArea : Entity, IEquatable<EffectArea>, IEntityBody
	{
		private EventHandler<EventArgs> Expired;
		protected Vector2 forward;
		protected Func<Vector2> positionFunc;
		protected Func<int, Shape> collisionShapeFunc;
		private HashSet<EntityId> hitBattleEntities;
		public Battle Battle { get; set; }
		public BattleEntity Invoker { get; set; }
		public EntityId InvokerId { get; }
		public string SkillEntityName { get; }
		public abstract Vector2 Position2D { get; set; }
		public virtual Vector2 Forward { get; set; }
		public bool IsExpired { get; }
		public int Elapsed { get; set; }
		public int Duration { get; }
		public virtual SkillSpecification SkillSpecification { get; }
		protected AreaEntityValue EntityValue { get; }
		protected Nullable<AreaCollisionProperty> CollisionProperty { get; }
		public bool RotateEntityDirectionEveryFrame { get; }
		public bool ApplyOffsetRotateEntityDirection { get; }
		protected IList<int> HitFrames { get; }
		public Body2D CollisionBody { get; set; }
		protected Vector2 InitialPosition { get; set; }
		public BattleEntity PositionSource { get; set; }
		protected BattleEntity TargetSource { get; set; }
		protected Vector2 TargetPosition { get; set; }
		public virtual int ExtraCostUsed { get; }
		protected HitCheckCoupling HitCheckCoupling { get; set; }
		public bool IsDisable { get; set; }
		public MovingAreaOptions MovingAreaOption { get; }
		public bool Equals(EffectArea other)
		{
			return default;
		}

		public Body2D GetBody2D()
		{
			return default;
		}

	}

	[Serializable]
	public struct EntityId : IComparable, IComparable<EntityId>, IEquatable<EntityId>
	{
		private const uint typeMask = 4278190080;
		private const int instanceIdMask = 16777215;
		private int uniqueId;
		public static EntityId Invalid { get; }
	
		[JsonIgnore]
		public BattleEntityType EntityType { get; }
	
		[JsonIgnore]
		public int InstanceId { get; }
	
		[JsonIgnore]
		public int UniqueId { get; }
	
		[JsonIgnore]
		public bool IsValid { get; }
		public int CompareTo(object obj)
		{
			return default;
		}

		public int CompareTo(EntityId other)
		{
			return default;
		}

		public bool Equals(EntityId other)
		{
			return default;
		}

	}

	public class BattleItem : BattleEntity
	{
		private EventHandler<BattleEntityRemovedEventArgs> Expired;
		private EventHandler<BattleItemActivatedEventArgs> Activated;
		private EventHandler<BattleItemRecognitionEventArgs> Recognized;
		private EventHandler<BattleItemEffectEventArgs> Effected;
		protected Battle battle;
		protected bool isAlive;
		protected int elapsed;
		public SkillSpecification SkillSpecification { get; }
		protected BattleItemEntityValue EntityValue { get; }
		public string EntityName { get; }
		public string ResourceName { get; }
		protected Body2D bodyToRecognize { get; }
		protected Body2D bodyToEffect { get; }
		public Circle RecognizeCircle { get; }
		public Circle EffectCircle { get; }
		public float PositionHeight { get; set; }
		public override GroupTag GroupTag { get; }
		public HashSet<BattleEntity> HitTargets { get; }
		public HashSet<BattleEntity> RecognizedTargets { get; }
		public BattleEntity Creator { get; }
		public bool IsExpired { get; set; }
		public int IndexSummonedBy { get; }
		public MovingAreaOptions MovingAreaOption { get; set; }
		public int ExtraSkillCostUsed { get; }
		protected BattleEntity SkillCommandSelectedTarget { get; set; }
		protected Vector2 SkillCommandSelectedPosition { get; set; }
		public override bool Alive { get; }
		public override BehaviorType CurrentBehavior { get; set; }
		public override ActionState CurrentActionState { get; }
		public override HeroAction CurrentAction { get; set; }
		public override bool HasCrowdControl { get; }
	}

	public abstract class Projectile : Entity, IEquatable<Projectile>, IEntitySpawnable, IEntityBody
	{
		private EventHandler<ProjectileEventArgs> Collided;
		private EventHandler<ProjectileEventArgs> Expired;
		private IEntitySpawnable spawnable;
		private IList<BattleEntity> primaryTargets;
		public long ownerSkillRange;
		protected Vector2 targetPosition;
		protected MoveProjectileDelegate MoveProjectile;
		private int moveByFrameElapsed;
		public BattleEntity Invoker { get; }
		public EntityId InvokerId { get; }
		public virtual SkillSpecification SkillSpecification { get; }
		public virtual int ExtraCostUsed { get; }
		public string SkillEntityName { get; }
		public Body2D Body { get; set; }
		public Vector2 StartPos { get; set; }
		public Vector2 Position2D { get; }
		public Vector2 Direction { get; set; }
		public Vector2 Velocity { get; }
		protected bool IsHit { get; set; }
		protected List<int> HitOccurredFrame { get; set; }
		public int Elapsed { get; set; }
		public int FireDelay { get; }
		public int SplashDelay { get; }
		protected bool IsStickToTargetAfterHit { get; }
		public float Speed { get; }
		public long FrameToHit { get; }
		protected ProjectileEntityValue EntityValue { get; }
		protected AreaEntityValue SplashAreaEntity { get; }
		protected bool HasSplash { get; }
		protected HashSet<EntityId> HitHeroes { get; }
		private TargetCandidateRule TargetCandidateRule { get; }
		private TargetSortRule TargetSortRule { get; }
		public virtual BattleEntity Executer { get; }
		public bool Equals(Projectile other)
		{
			return default;
		}

		public BattleEntity FindTarget(SkillEntityValue entityData)
		{
			return default;
		}

		public IList<BattleEntity> FindTargets(SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 FindSpawnPosition(Battle battle, SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 FindSpawnDirection(Battle battle, SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 GetInitialTargetPosition()
		{
			return default;
		}

		public BattleEntity GetSkillCommandSelectedTarget()
		{
			return default;
		}

		public Vector2 GetSkillCommandSelectedPosition()
		{
			return default;
		}

		public Body2D GetBody2D()
		{
			return default;
		}

	}

	public class Beam : Entity, IEquatable<Beam>, IEntitySpawnable, IEntityBody
	{
		private EventHandler<BeamEventArgs> Collided;
		private EventHandler<BeamEventArgs> Expired;
		private IEntitySpawnable spawnable;
		private IList<BattleEntity> primaryTargets;
		private long ownerSkillRange;
		private Vector2 startPosition;
		private Vector2 targetPosition;
		private float currentHeight;
		private Battle battle;
		public virtual BattleEntity Executer { get; }
		public virtual SkillSpecification SkillSpecification { get; }
		public string SkillEntityName { get; }
		public Body2D Body { get; set; }
		public Vector2 Position2D { get; }
		public Vector2 Direction { get; set; }
		public int Elapsed { get; set; }
		public int ElapsedInCurrentPhase { get; set; }
		protected BeamEntityValue EntityValue { get; }
		protected HashSet<EntityId> HitHeroes { get; }
		private TargetCandidateRule TargetCandidateRule { get; }
		private TargetSortRule TargetSortRule { get; }
		public Vector2 StartPosition { get; }
		public BattleEntity StartPositionEntity { get; set; }
		public Vector2 TargetPosition { get; }
		public BattleEntity TargetPositionEntity { get; set; }
		public BeamPhase CurrentPhase { get; set; }
		public BattleEntity ChainBeamSpawner { get; set; }
		public virtual int ExtraCostUsed { get; }
		public bool Equals(Beam other)
		{
			return default;
		}

		public BattleEntity FindTarget(SkillEntityValue entityData)
		{
			return default;
		}

		public IList<BattleEntity> FindTargets(SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 FindSpawnPosition(Battle battle, SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 FindSpawnDirection(Battle battle, SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 GetInitialTargetPosition()
		{
			return default;
		}

		public BattleEntity GetSkillCommandSelectedTarget()
		{
			return default;
		}

		public Vector2 GetSkillCommandSelectedPosition()
		{
			return default;
		}

		public Body2D GetBody2D()
		{
			return default;
		}

	}

	public class Aura : Entity, IEquatable<Aura>, IEntityBody
	{
		private EventHandler<AuraEventArgs> Expired;
		private EventHandler<AuraEventArgs> SpawnTargetDied;
		private Battle battle;
		private Vector2 initialPosition;
		private Vector2 targetPosition;
		private HashSet<BattleEntity> HitBattleEntityList;
		public BattleEntity Invoker { get; set; }
		public EntityId InvokerId { get; }
		public SkillSpecification SkillSpecification { get; }
		public string SkillEntityName { get; }
		public Vector2 Position2D { get; }
		public Vector2 Forward { get; }
		public Body2D Body { get; set; }
		public Body2D BodyExitCheck { get; set; }
		public bool IsExpired { get; }
		public bool IsSpawnTargetDead { get; set; }
		public int Elapsed { get; set; }
		public int Duration { get; }
		private AuraEntityValue EntityValue { get; }
		public bool RemoveEntityIfAttachSpawnTargetDie { get; }
		public bool RotateEntityDirectionEveryFrame { get; }
		public bool ApplyOffsetRotateEntityDirection { get; }
		public bool AttachSpawnTarget { get; }
		public BattleEntity PositionSource { get; set; }
		public BattleEntity TargetSource { get; set; }
		public int ExtraCostUsed { get; }
		public MovingAreaOptions MovingAreaOption { get; }
		public bool Equals(Aura other)
		{
			return default;
		}

		public Body2D GetBody2D()
		{
			return default;
		}

	}

	public class NormalAttackDeliverer : Entity, IEquatable<NormalAttackDeliverer>
	{
		private EventHandler<NormalAttackDelivererEventArgs> Hit;
		private long elapsed;
		private Vector2 startPosition;
		public SkillSpecification SkillSpecification { get; }
		public Vector2 HitPosition { get; set; }
		public BattleEntity Invoker { get; set; }
		public BattleEntity Target { get; set; }
		public IObstacle Obstacle { get; set; }
		public int DelayToHitTarget { get; set; }
		private int DelayToObstacleBlockCheck { get; set; }
		private NormalAttackBulletEntityValue BulletEntityData { get; }
		public SkillApplyType SkillApplyType { get; }
		public string SkillEntityName { get; }
		public bool Equals(NormalAttackDeliverer other)
		{
			return default;
		}

	}

	public abstract class SpawningEntity : Entity, IEntitySpawnable, IHitCheckCouplingProvider
	{
		private EventHandler<EventArgs> Expired;
		private Dictionary<int, Dictionary<string, HitCheckCoupling>> couplingTable;
		private BattleEntity skillCommandSelectedTarget;
		private Vector2 skillCommandSelectedPosition;
		public virtual SkillSpecification SkillSpecification { get; }
		public virtual int ExtraCostUsed { get; }
		public virtual BattleEntity Executer { get; }
		protected int Elapsed { get; set; }
		protected int Duration { get; }
		protected bool IsExpired { get; }
		public BattleEntity FindTarget(SkillEntityValue entityData)
		{
			return default;
		}

		public IList<BattleEntity> FindTargets(SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 FindSpawnPosition(Battle battle, SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 FindSpawnDirection(Battle battle, SkillEntityValue entityData)
		{
			return default;
		}

		public Vector2 GetInitialTargetPosition()
		{
			return default;
		}

		public BattleEntity GetSkillCommandSelectedTarget()
		{
			return default;
		}

		public Vector2 GetSkillCommandSelectedPosition()
		{
			return default;
		}

		public HitCheckCoupling GetHitCheckCoupling(int frame, string couplingId)
		{
			return default;
		}

	}

	[Serializable]
	public class GroundObstacle : BattleEntity, IObstacle
	{
		private EventHandler<ObstacleEventArgs> Removed;
		private EventHandler<ObstacleEventArgs> StateChanged;
		private EventHandler<ObstacleEventArgs> GroundNodeChanged;
		private EventHandler<EventArgs> Activated;
		private Dictionary<ObstaclePoint, Character> playerPointsCharacterTable;
		private Dictionary<ObstaclePoint, Character> enemyPointsCharacterTable;
		private int elapsed;
		private IEnumerator currentStateChangeCoroutine;
		private bool IsInvokerGroupTag1;
		public GroundObstacleData Data { get; set; }
		public virtual EntityMaterialType MaterialType { get; }
		public virtual ObstacleHeightType ObstacleHeight { get; }
		public virtual CoverMotionType CoverMotionType { get; }
		public virtual ObstacleCoverType ObstacleCoverType { get; }
		public Nullable<ObstacleStatExcel> StatExcel { get; set; }
		public Circle InnerCircle { get; set; }
		public OBB OBB { get; set; }
		public bool IsCrashByTSS { get; set; }
		public OBB TSSBlockedOBB { get; set; }
		public bool IsIndestructible { get; set; }
		public virtual bool IsDestroyed { get; set; }
		public List<ObstaclePoint> PlayerPoints { get; set; }
		public List<ObstaclePoint> EnemyPoints { get; set; }
		public Battle Battle { get; set; }
		public float PositionHeight { get; set; }
		public MovingAreaOptions MovingAreaOption { get; set; }
		public ObstacleState State { get; set; }
		public ObstacleState RemoveType { get; set; }
		public override bool Alive { get; }
		public override GroupTag GroupTag { get; }
		public ObstacleSaveData ObstacleSaveData { get; set; }
		public virtual BattleEntityStatProcessor StatProcessor { get; }
		public bool IsDummy { get; set; }
		public int Duration { get; set; }
		public virtual float LifeTimeRate { get; }
		public virtual bool IsOccupied { get; }
		public long CanNotStandRange { get; set; }
		public IList<Character> OccupyingCharacters { get; }
		public override BehaviorType CurrentBehavior { get; set; }
		public override ActionState CurrentActionState { get; }
		public override HeroAction CurrentAction { get; set; }
		public override bool HasCrowdControl { get; }
		public BattleEntity Summoner { get; set; }
		public int IndexSummonedBy { get; set; }
		public SkillSpecification SkillSpecificationWhenSummoned { get; set; }
		public AreaSpawner InitialAreaSpawner { get; set; }
		public virtual BattleEntity Entity { get; }
		public bool IsObstacleOccupiedByCharacter(Character character)
		{
			return default;
		}

		public bool IsOccupiedByPlayer(GroupTag groupTag)
		{
			return default;
		}

		public bool IsOccupiedByEnemy(GroupTag groupTag)
		{
			return default;
		}

		public bool IsLineIntersect(LineSegment line)
		{
			return default;
		}

		public void DestroyObstacle()
		{
		}

		public void DispelByGroupId(string logicEffectGroupId, int count, StatusProcessor statusProcessor, Action<List<string>> onDispel)
		{
		}

		public BattleEntity GetSummoner()
		{
			return default;
		}

	}

	[Serializable]
	public class BarrierObstacle : BattleEntity, IObstacle
	{
		private string obstacleId;
		private EntityMaterialType materialType;
		private EventHandler<EventArgs> Removed;
		public Battle Battle { get; set; }
		public int Duration { get; set; }
		private int CreatedFrame { get; set; }
		private int Elapsed { get; set; }
		public virtual float LifeTimeRate { get; }
		public Character Character { get; set; }
		public BattleEntity Summoner { get; set; }
		public int IndexSummonedBy { get; set; }
		public SkillSpecification SkillSpecificationWhenSummoned { get; set; }
		public bool FixDirection { get; set; }
		public Vector2 PositionOffset { get; }
		public string[] LinkedLogicEffectGroupIds { get; set; }
		public Nullable<ObstacleStatExcel> StatExcel { get; set; }
		public virtual BattleEntityStatProcessor StatProcessor { get; }
		private long ObstacleIdHash { get; set; }
		public string ObstacleId { get; set; }
		public virtual bool IsDestroyed { get; set; }
		public override bool Alive { get; }
		public override GroupTag GroupTag { get; }
		public override BehaviorType CurrentBehavior { get; set; }
		public override ActionState CurrentActionState { get; }
		public override HeroAction CurrentAction { get; set; }
		public virtual bool IsOccupied { get; }
		public AreaSpawner InitialAreaSpawner { get; set; }
		public virtual EntityMaterialType MaterialType { get; }
		public virtual ObstacleHeightType ObstacleHeight { get; }
		public virtual CoverMotionType CoverMotionType { get; }
		public virtual ObstacleCoverType ObstacleCoverType { get; }
		public virtual BattleEntity Entity { get; }
		public override bool HasCrowdControl { get; }
		public bool IsObstacleOccupiedByCharacter(Character character)
		{
			return default;
		}

		public bool IsOccupiedByPlayer(GroupTag groupTag)
		{
			return default;
		}

		public bool IsOccupiedByEnemy(GroupTag groupTag)
		{
			return default;
		}

		public bool IsLineIntersect(LineSegment line)
		{
			return default;
		}

		public void DestroyObstacle()
		{
		}

		public void DispelByGroupId(string logicEffectGroupId, int count, StatusProcessor statusProcessor, Action<List<string>> onDispel)
		{
		}

		public BattleEntity GetSummoner()
		{
			return default;
		}

	}

	public class Character : BattleEntity, IHeroSummarizable, ICharacter
	{
		private int lastTargetFindFrame;
		private EventHandler<ActionChangedEventArgs> ActionChangedVolatileCurrentAction;
		private EventHandler<ActionChangedEventArgs> ActionChanged;
		private EventHandler<ActionChangedEventArgs> ActionInterrupted;
		private EventHandler<StatusAddedEventArgs> StatusAdded;
		private EventHandler<StatusRemovedEventArgs> StatusRemoved;
		private EventHandler<StatusResistEventArgs> StatusResisted;
		private EventHandler<ImmuneAddedEventArgs> ImmuneAdded;
		private EventHandler<ImmuneRemovedEventArgs> ImmuneRemoved;
		private EventHandler<KillEventArgs> Died;
		private EventHandler<HeroReviveEventArgs> Revived;
		private EventHandler<KillEventArgs> DyingStarted;
		private EventHandler<CharacterGroundNodeChangedEventArgs> GroundNodeChanged;
		private EventHandler<CharacterPhaseChangedEventArgs> PhaseChanged;
		public EventHandler<EventArgs> AmmoReloaded;
		public EventHandler<CharacterBulletCountChangedEventArgs> BulletCountChanged;
		public EventHandler<CharacterFormConvertedEventArgs> FormChanged;
		public EventHandler<CharacterInteractWithTSSEventArgs> InteractWithTSS;
		public EventHandler<CoverStateChangedEventArgs> CoverStateChanged;
		public EventHandler<SkillActionRegisteredEventArgs> SkillActionRegistered;
		public EventHandler<BarrierObstacle> BarrierObstacleCoverChanged;
		public readonly bool IsDefenseCharacter;
		private ImmediateKillEffect reservedImmediateKillEffectFromTSADestruction;
		private LogicEffect reservedDamageEffectFromTSADestruction;
		public List<Nullable<ValueTuple<ExpirableObjectHolder<StatusResult>, BattleEntity>>> TauntBattleEntityList;
		private Dictionary<SkillSlot, int> ExtraSkillCostTable;
		public MoveToWorldPositionCommand CurrentMoveToWorldPositionCommand;
		private EventHandler<DebuffEventArgs> DebuffAdded;
		public Dictionary<long, Dictionary<ExternalBTTrigger, Dictionary<string, List<List<BossExternalBTExcel>>>>> ExternalBTExcelsByArgumentByTriggerByPhaseTable;
		private long currentActiveGauge;
		private Dictionary<string, int> SkillGroupToUseCountDictionary;
		protected List<List<BossExternalBTExcel>> executedInstantNodeList;
		protected Func<bool> HasFormationBeacon { get; set; }
		protected Func<bool> CheckMoveToAttackPath { get; set; }
		protected Func<bool> CheckFormationBeaconPath { get; set; }
		protected bool IsSearchAndMoveActivated { get; set; }
		public bool IsCurrentActionExSkill { get; }
		public bool IsCurrentActionPublicSkill { get; }
		public bool IsCurrentActionNormalAttack { get; }
		private bool IsCurrentActionFinished { get; }
		public long CurrentTargetSkillRange { get; }
		public long CurrentTargetSkillRangeWithoutInitialRate { get; }
		public bool IsCurrentTargetInRangeAndLineOfFireOk { get; }
		protected static CharacterExcel InvalidCharacter { get; }
		protected static CharacterAIExcel InvalidAI { get; }
		public virtual long ServerId { get; set; }
		public virtual long OwnerAccountId { get; set; }
		public virtual long CharacterId { get; set; }
		public virtual long CostumeId { get; }
		public virtual long CharacterSkillListGroupId { get; set; }
		public virtual long PersonalityId { get; set; }
		public long AIPatternId { get; set; }
		public virtual bool CheckCanUseAutoPublicSkill { get; }
		public FormationLine Line { get; set; }
		public int LineIndex { get; set; }
		public bool IsAttacked { get; set; }
		private bool canUseObstacleOfStandMotionDefault { get; }
		private bool canUseObstacleOfKneelMotionDefault { get; }
		public bool CanUseObstacleOfStandMotion { get; }
		public bool CanUseObstacleOfKneelMotion { get; }
		public virtual bool IsNPC { get; set; }
		public bool IsAirUnit { get; set; }
		public long AirUnitHeight { get; set; }
		public virtual BulletType BulletType { get; }
		public long RandomEffectRaidus { get; set; }
		public EngageType EngageType { get; set; }
		public EntityMaterialType MaterialType { get; set; }
		public virtual School School { get; set; }
		public PositioningSetting PositioningSetting { get; set; }
		public long BulletCount { get; set; }
		public virtual int FavorRank { get; set; }
		public int FormCount { get; set; }
		public HashSet<long> TSAInteractionIds { get; set; }
		public virtual Dictionary<StatType, int> PotentialStatLevelDict { get; set; }
		public MovingAreaOptions MovingAreaOption { get; set; }
		public virtual BattleEntityStatProcessor StatProcessor { get; }
		public SkillProcessor SkillProcessor { get; set; }
		public PassiveSkillProcessor PassiveSkillProcessor { get; set; }
		public StatusProcessor StatusProcessor { get; set; }
		public int CrowdControlCount { get; }
		public int CrowdControlDuration { get; }
		public BehaviorTree BehaviorTree { get; set; }
		public override bool Alive { get; }
		protected Battle battleCache { get; set; }
		public virtual Battle BattleCache { get; }
		public virtual CharacterGroup CharacterGroup { get; set; }
		public override GroupTag GroupTag { get; }
		public CoverState CoverState { get; }
		private IObstacle LinkedObstacle { get; set; }
		public bool IsMobile { get; }
		public bool IsRootMotionAllowed { get; }
		public bool IsKnockbackable { get; }
		public bool IsDefaultMobile { get; set; }
		public bool CanSurvive { get; set; }
		public bool CheckTSSBlocked { get; }
		public GroundNodeType PassableNodeType { get; }
		public bool CanAttackWhileMove { get; set; }
		public bool IsJumpable { get; set; }
		public bool IsOnJump { get; set; }
		public bool IsOnMoveEndRootMotion { get; set; }
		public bool IsWeaponMounted { get; set; }
		public WeaponType WeaponType { get; set; }
		public Dictionary<ValueTuple<BulletType, ArmorType>, ValueTuple<long, DamageAttribute, long, long, bool>> BulletArmorFactorTable { get; set; }
		public Dictionary<SkillSlot, List<ValueTuple<BulletType, int>>> BulletTypeOverrideTable { get; set; }
		public Dictionary<BulletType, List<ValueTuple<long, long, int, SkillSlot>>> BulletArmorDamageFactorOverrideTable { get; set; }
		public List<Tag> TagList { get; }
		public int JumpMotionFrame { get; set; }
		public int MoveStartFrame { get; set; }
		public int MoveEndFrame { get; set; }
		public int DeadFrame { get; set; }
		public int AppearFrame { get; set; }
		public bool IsAppearFinished { get; set; }
		public AppearSetting AppearSetting { get; set; }
		public bool IsInteractionTSAFinished { get; set; }
		public PathFinder PathFinder { get; set; }
		public bool IsForceIdle { get; set; }
		public ForceMoveCommandInfo CurrentForceMoveCommandInfo { get; set; }
		public ForceHoldCommandInfo CurrentForceHoldCommandInfo { get; set; }
		public SkillCommandInfo CurrentSkillCommandInfo { get; set; }
		private TSAInteractionState CurrentTSAInteractionState { get; set; }
		public bool IsInteractWithTSS { get; }
		public bool IsInteractWithDyingTSA { get; }
		public bool IsInteractWithAliveTSA { get; }
		public bool IsPrivateWeapon { get; set; }
		public virtual WeaponSetting WeaponSetting { get; set; }
		public virtual GearSetting GearSetting { get; set; }
		public virtual CostumeSetting CostumeSetting { get; set; }
		public RootMotionFlat RootMotionFlat { get; set; }
		public CharacterFormRootMotion[] FormRootMotions { get; set; }
		public RootMotionFrame[] ExSkillRootMotions { get; set; }
		public RootMotionFrame MoveLeftRootMotion { get; set; }
		public RootMotionFrame MoveRightRootMotion { get; set; }
		public bool IsRootMotionInLastMove { get; set; }
		public bool IsAttackEnterSkipByLastSkill { get; set; }
		public FormConversionInfo CurrentForm { get; set; }
		public FormConversionInfo FormToConvert { get; set; }
		public bool IsFormConversed { get; }
		public int FormIndex { get; }
		public virtual CharacterSkillListKey SkillListKey { get; }
		public bool RequireReleaseFormConversion { get; }
		public ShieldInfo CurrentShield { get; set; }
		public TemporaryHpInfo CurrentTemporaryHp { get; set; }
		public long TemporaryHpValue { get; }
		public KnockbackInfo CurrentKnockbackInfo { get; set; }
		public bool CanBattleItemMove { get; }
		public bool CanNormalAttackTarget { get; }
		public ActionLock ActionLock { get; set; }
		protected IDictionary<ValueTuple<BehaviorType, CharacterSkillListKey>, HeroAction> ActionTable { get; set; }
		public override HeroAction CurrentAction { get; set; }
		public BehaviorType PrevBehavior { get; set; }
		public override BehaviorType CurrentBehavior { get; set; }
		public BehaviorType NextForcedBehavior { get; set; }
		public ActionProgress CurrentActionProgress { get; }
		public int CurrentActionElapsed { get; }
		public int CurrentActionDuration { get; }
		public int CurrentActionRemain { get; }
		public bool IsReloading { get; }
		public bool DyingEnabled { get; }
		public override ActionState CurrentActionState { get; }
		public HashSet<HeroStatus> StatusSet { get; }
		public HeroStatus ForceActionStatus { get; }
		public override bool HasCrowdControl { get; }
		public IEnumerable<ExpirableObjectHolder<StatusResult>> RuntimeStatus { get; }
		public List<ExpirableObjectHolder<StatChangeEffect>> RuntimeEffects { get; }
		protected EquipmentProcessor EquipmentProcessor { get; set; }
		public virtual IList<Equipment> Equipments { get; }
		public virtual HeroSummaryDetailFlag SummaryDetail { get; }
		public SequentialSkillCardManager SkillCardManager { get; set; }
		public long AIPhase { get; set; }
		public long AIPhaseToChange { get; set; }
		public long CurrentActiveGauge { get; set; }
		private int CurrentNormalAttackCount { get; set; }
		public void DispelByGroupId(string logicEffectGroupId, int count, StatusProcessor statusProcessor, Action<List<string>> onDispel)
		{
		}

		public void AddStatus(StatusParams statusResult)
		{
		}

		public void RemoveStatus(HeroStatus status)
		{
		}

		public void RemoveStatus(HeroStatus status, string skillGroupId)
		{
		}

		public bool HasStatus(HeroStatus status)
		{
			return default;
		}

	}

	public class OverrideStageTopographyEffect : LogicEffect
	{
		public EndCondition EndCondition { get; }
		public string EndConditionArgumentFirst { get; }
		public string EndConditionArgumentSecond { get; }
		public StageTopography StageTopography { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	public class LogicGameTime
	{
		public const int LogicFramePerSecond = 30;
		public static readonly long TicksPerFrame;
		public float UnitySecondPerFrame { get; }
		public TimeSpan SecondPerFrame { get; }
		public int FramePerSecond { get; }
		public TimeSpan TotalGameTime { get; set; }
		public int TotalSeconds { get; }
		public float TotalGameTimeSecond { get; }
		public int CurrentFrame { get; set; }
		public bool Paused { get; set; }
		public int TimeoutFrame { get; set; }
		public bool Timeout { get; set; }
	}

	public interface IPseudoRandomService : IRandomService
	{
		public abstract int Sequence { get; }
		public abstract ulong Seed { get; }
		public int Next()
		{
			return default;
		}

		public int Next(int maxValue)
		{
			return default;
		}

		public int Next(int minValue, int maxValue)
		{
			return default;
		}

		public int NextIncludeMax(int minValue, int maxValue)
		{
			return default;
		}

		public float NextFloat()
		{
			return default;
		}

		public double NextDouble()
		{
			return default;
		}

		public ulong NextULong()
		{
			return default;
		}

	}

	public class BattleEntityIdProvider
	{
		private IDictionary<BattleEntityType, int> lastInstanceIds;
	}

	public sealed class LogicEffectProcessor
	{
		private EventHandler<LifeGainEventArgs> LifeGain;
		private EventHandler<LogicEffectHitEventArgs> LogicEffectHit;
		private EventHandler<LogicEffectHitEventArgs> DotApply;
		private EventHandler<LogicEffectImmuneEventArgs> LogicEffectImmune;
		private EventHandler<AttackEventArgs> AttackProcessed;
		private EventHandler<DamageResultEventArgs> DamageProcessed;
		private bool debugProcessState;
		private List<LogicEffect> logicEffects { get; }
		private DataLogicEffectComparer priorityComparer { get; }
	}

	public class BattleEventBroker
	{
		private BattleEventSnapshot currentSnapshot;
		public BattleSetting Setting { get; set; }
		public KeyedCollection<int, BattleEventSnapshot> BattleSnapshot { get; }
	}

	public sealed class BattleSetting : IEquatable<BattleSetting>
	{
		public BattleTypes BattleType { get; set; }
		public EchelonType EchelonType { get; set; }
		public int RandomSeed { get; set; }
		public int BattleDurationInFrame { get; set; }
		public TeamSetting LeftTeam { get; set; }
		public TeamSetting RightTeam { get; set; }
		public long GroundUniqueId { get; set; }
		public long StageId { get; set; }
		public string StageNumber { get; set; }
		public string StageName { get; set; }
		public TacticEnvironment EnvironmentType { get; set; }
	
		[JsonIgnore]
		public StageTopography StageTopography { get; set; }
	
		[JsonIgnore]
		public string GroundSceneName { get; set; }
	
		[JsonIgnore]
		public string GroundGridFileName { get; set; }
	
		[JsonIgnore]
		public string GroundStageName { get; set; }
		public bool IsDefeatBattle { get; set; }
	
		[JsonIgnore]
		public bool HideBattleUIFromScratch { get; set; }
	
		[JsonIgnore]
		public long TSSAirUnitHeight { get; set; }
	
		[JsonIgnore]
		public long PlayerPositionGapRate { get; set; }
	
		[JsonIgnore]
		public long EnemyPositionGapRate { get; set; }
		public bool IsBoss { get; set; }
		public List<ClanAssistUseInfo> ClanAssistUseInfo { get; set; }
	
		[JsonIgnore]
		public int RaidBossInitialPhase { get; }
		public RaidSetting RaidSetting { get; set; }
		public EventBattleSetting EventSetting { get; set; }
		public TimeAttackSetting TimeAttackSetting { get; set; }
		public long ConquestGroupBuffId { get; set; }
		public ConquestEnemyType ConquestEnemyType { get; set; }
	
		[JsonIgnore]
		public long EventContentId { get; set; }
	
		[JsonIgnore]
		public long FixedEchelonId { get; set; }
		public bool DisableRootMotion { get; set; }
	
		[JsonIgnore]
		public Dictionary<TacticEntityType, List<long>> BattleRewardItems { get; set; }
		public bool Equals(BattleSetting other)
		{
			return default;
		}

	}

	public abstract class CharacterGroup
	{
		private EventHandler<SightChangedEventArgs> SightChanged;
		public List<SupportActor> Supporters;
		private bool[] sightGrids;
		public List<BlockedArea> BlockedAreas;
		private HashSet<int> aiGroupIdOfAttackedCharacter;
		private HashSet<Character> AttackedCharacter;
		private List<SupportActor> supportersToRemove;
		private HashSet<Character> discoveredEnemies;
		private int currentSectionId;
		public GroupTag GroupTag { get; set; }
		public long TeamId { get; set; }
		public int MaxCharacterCount { get; }
		public string SupportActionUniqueName { get; set; }
		public bool IsExtension { get; set; }
		public List<Character> ActiveCharacters { get; set; }
		public List<Character> AliveCharacters { get; set; }
		public bool HasSurvivor { get; set; }
		public List<Character> CharactersInSight { get; }
		public List<Character> CharactersInSightIncludeDead { get; }
		public BattleEntity Leader { get; set; }
		public Dictionary<ValueTuple<FormationLine, int>, GroundFormationBeacon> FormationBeacons { get; set; }
		public StatCorrection StatCorrection { get; }
		public bool CheckTSSInteractionServerId { get; set; }
		public long TSSInteractionServerId { get; set; }
		public long TSSInteractionUniqueId { get; set; }
		public int HandCount { get; set; }
		public bool IgnoreSkillCardShuffle { get; set; }
		public Dictionary<ValueTuple<int, TacticEntityType>, SkillCardManager> SkillCardManagerTable { get; set; }
		public bool[] SightGrids { get; set; }
		public int MaxCharacterLevel { get; }
		public Dictionary<Character, long> ConcentratedTargetTable { get; set; }
		public bool HasNotMoveLogicEffectCharacter { get; }
		public int GroupId { get; set; }
		public SkillActor SkillActor { get; set; }
		public Battle BattleCache { get; set; }
		public List<TemporaryCanUseSkillArea> TemporaryCanUseSkillAreas { get; set; }
		public bool SkipUntargetableTargetCheckInMove { get; set; }
		public bool SightRangeMax { get; }
		public long PositionGapRate { get; }
		public SyncUseSkillManager SyncUseSkillManager { get; }
		public Vector2 Center { get; }
		public Vector2 Forward { get; }
	}

	public class SupportActor : SkillActor, ICharacter
	{
		private EventHandler<BattleEntityRemovedEventArgs> Expired;
		public EventHandler<CharacterInteractWithTSSEventArgs> InteractWithTSS;
		public virtual long ServerId { get; }
		public virtual long OwnerAccountId { get; }
		public virtual long CharacterId { get; }
		public virtual long CostumeId { get; }
		public virtual long CharacterSkillListGroupId { get; }
		public virtual long PersonalityId { get; }
		public virtual School School { get; }
		public WeaponType WeaponType { get; }
		public virtual BulletType BulletType { get; }
		public virtual int FavorRank { get; set; }
		public virtual Dictionary<StatType, int> PotentialStatLevelDict { get; set; }
		public PassiveSkillProcessor PassiveSkillProcessor { get; }
		public virtual BattleEntityStatProcessor StatProcessor { get; }
		public override bool HasCrowdControl { get; }
		public bool IsInteractWithTSS { get; set; }
		public virtual CharacterGroup CharacterGroup { get; }
		public bool IsPrivateWeapon { get; set; }
		public virtual WeaponSetting WeaponSetting { get; set; }
		public virtual GearSetting GearSetting { get; set; }
		public virtual CostumeSetting CostumeSetting { get; set; }
		public List<Tag> TagList { get; }
		public virtual bool IsNPC { get; }
		public virtual bool CheckCanUseAutoPublicSkill { get; }
		public override HeroSummaryDetailFlag SummaryDetail { get; }
		public bool IsCurrentActionExSkill { get; }
		private bool IsCurrentActionPublicSkill { get; }
		protected EquipmentProcessor EquipmentProcessor { get; set; }
		public virtual IList<Equipment> Equipments { get; }
		public void DispelByGroupId(string logicEffectGroupId, int count, StatusProcessor statusProcessor, Action<List<string>> onDispel)
		{
		}

		public void AddStatus(StatusParams statusResult)
		{
		}

		public void RemoveStatus(HeroStatus status)
		{
		}

		public void RemoveStatus(HeroStatus status, string skillGroupId)
		{
		}

		public bool HasStatus(HeroStatus status)
		{
			return default;
		}

	}

	public class Ground
	{
		public GroundGrid Grid { get; set; }
		public GroundStage Stage { get; set; }
		public int GridNodeLength { get; }
	}

	public class BattleCommandExecuter
	{
		private List<BattleCommand> commands { get; }
	}

	public abstract class BattleCommandQueue
	{
		protected Queue<BattleCommand> Queue { get; }
	}

	public class GroundEntitySpawner
	{
		private Battle battle;
	}

	public class SpawnProcessor
	{
		private List<Character> spawnReserves;
		private List<SupportActor> supporterSpawnReserves;
	}

	public class HeroSummary : IEquatable<HeroSummary>
	{
		[JsonIgnore]
		private readonly BattleEntityType[] AllBattleEntity;
		[JsonIgnore]
		private BattleEntity entityCache;
		[JsonIgnore]
		private long stabilitySum;
		[JsonIgnore]
		private int stabilityCount;
		[JsonIgnore]
		private int attackHitCount;
		[JsonIgnore]
		private int attackTotalCount;
		[JsonIgnore]
		private long prevHitPoint;
		[JsonIgnore]
		private SupportActor supportCache;
		public long ServerId { get; set; }
		public long OwnerAccountId { get; set; }
		public EntityId BattleEntityId { get; set; }
		public long CharacterId { get; set; }
		public long CostumeId { get; set; }
		public int Grade { get; set; }
		public int Level { get; set; }
		public IDictionary<StatType, int> PotentialStatLevel { get; set; }
		public int ExSkillLevel { get; set; }
		public int PublicSkillLevel { get; set; }
		public int PassiveSkillLevel { get; set; }
		public int ExtraPassiveSkillLevel { get; set; }
		public int FavorRank { get; set; }
		public StatSnapshotCollection StatSnapshotCollection { get; set; }
		public long HPRateBefore { get; set; }
		public long HPRateAfter { get; set; }
		public int CrowdControlCount { get; set; }
		public int CrowdControlDuration { get; set; }
		public int EvadeCount { get; set; }
		public int DamageImmuneCount { get; set; }
		public int CrowdControlImmuneCount { get; set; }
		public long MaxAttackPower { get; set; }
		public int AverageCriticalRate { get; set; }
		public int AverageStabilityRate { get; set; }
		public int AverageAccuracyRate { get; set; }
		public int DeadFrame { get; set; }
		public long DamageGivenAbsorbedSum { get; set; }
		public TacticEntityType TacticEntityType { get; set; }
	
		[JsonIgnore]
		public HeroSummaryDetailFlag DetailFlag { get; }
	
		[JsonIgnore]
		public bool IsDead { get; }
		public List<BattleNumericLog> GivenNumericLogs { get; set; }
		public List<BattleNumericLog> TakenNumericLogs { get; set; }
		public List<BattleNumericLog> ObstacleBattleNumericLogs { get; set; }
		public List<EquipmentSetting> Equipments { get; set; }
		public Nullable<WeaponSetting> CharacterWeapon { get; set; }
		public Nullable<GearSetting> CharacterGear { get; set; }
	
		[JsonIgnore]
		public IDictionary<int, long> HitPointByFrame { get; set; }
		public IDictionary<SkillSlot, int> SkillCount { get; set; }
	
		[JsonIgnore]
		public int ExSkillUseCount { get; }
		public KillLogCollection KillLog { get; set; }
	
		[JsonIgnore]
		public int KillCount { get; }
	
		[JsonIgnore]
		public Dictionary<int, string> FullSnapshot { get; set; }
		public static IEqualityComparer<HeroSummary> HeroSummaryAlmostEqualityComparer { get; }
		public bool Equals(HeroSummary other)
		{
			return default;
		}

	}

	public class SkillCostSummary
	{
		public float InitialCost { get; set; }
		public CostRegenSnapshotCollection CostPerFrameSnapshots { get; set; }
		public List<SkillCostAddSnapshot> CostAddSnapshots { get; set; }
		public List<SkillCostUseSnapshot> CostUseSnapshots { get; set; }
	}

	public class FindGiftSummary
	{
		public string UniqueName { get; set; }
		public int ClearCount { get; set; }
	}

	[Serializable]
	public class TBGHexaMapData
	{
		[JsonIgnore]
		public Dictionary<HexLocation, TBGHexaTileData> TileLocationMap;
		public List<TBGHexaTileData> Tiles { get; set; }
		public List<TBGHexaSpawnData> Spawns { get; set; }
	}

	public class TBGHexaObjectDB
	{
		private TBGBoardSaveDB _saveDB;
		private ITBGObjectInfo _objectInfoCache;
		private ITBGEncounterInfo _encounterInfoCache;
		private bool _activated;
		private Nullable<int> _hitPoint;
		private Nullable<int> _beforeStoryOption;
		private bool _encounterCostAlreadyPaid;
		private Nullable<bool> _isFakeTrasure;
		private Dictionary<int, long> _FixRewardUniqueIdByIndex;
	
		[JsonIgnore]
		public bool IsDirty { get; set; }
	
		[JsonIgnore]
		public ITBGObjectInfo ObjectInfo { get; }
	
		[JsonIgnore]
		public ITBGEncounterInfo EncounterInfo { get; }
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public long EncounterId { get; set; }
		public TBGThemaType MapType { get; set; }
		public HexLocation Location { get; set; }
		public bool Activated { get; set; }
		public Nullable<int> HitPoint { get; set; }
		public Nullable<int> BeforeStoryOption { get; set; }
		public bool EncounterCostAlreadyPaid { get; set; }
		public Nullable<bool> IsFakeTreasure { get; set; }
		public Dictionary<int, long> FixRewardUniqueIdByIndex { get; set; }
	
		[JsonIgnore]
		public TBGObjectInteractionType InteractionType { get; }
	
		[JsonIgnore]
		public bool CanSkipBeforeStory { get; }
	
		[JsonIgnore]
		public bool IsPassable { get; }
	
		[JsonIgnore]
		public bool IsBlockingPlayer { get; }
	
		[JsonIgnore]
		public bool ShouldPayEncounterCost { get; }
	
		[JsonIgnore]
		public bool IsInteractable { get; }
	}

	public struct TBGProbModify
	{
		public TBGProbModifyCondition ProbModifyCondition { get; set; }
		public int ProbModifyValue { get; set; }
		public int ProbModifyLimit { get; set; }
	}

	public interface ITBGItemEffectDB
	{
		public abstract ITBGItemInfo ItemInfo { get; }
		public abstract int Stack { get; }
		public abstract int RemainEncounterCounter { get; }
	}

	public interface ITBGItemInfo
	{
		public abstract long UniqueId { get; }
		public abstract TBGItemType ItemType { get; }
		public abstract TBGItemEffectType ItemEffectType { get; }
		public abstract int ItemParameter { get; }
		public abstract int EncounterCount { get; }
		public abstract string LocalizeEtcId { get; }
		public abstract string Icon { get; }
		public abstract string BuffIcon { get; }
		public abstract string DiceEffectAniClip { get; }
		public abstract bool BuffIconHUDVisible { get; }
	}

	public class CurrencyValue : IEquatable<CurrencyValue>
	{
		public static readonly IEnumerable<CurrencyTypes> DBCurrencyTypes;
		public static readonly IEnumerable<CurrencyTypes> DBPropertyCurrencyTypes;
		public static readonly IEnumerable<CurrencyTypes> DBTicketCurrencyTypes;
		public static readonly IEnumerable<CurrencyTypes> ValidCurrencyTypes;
		public static readonly IEnumerable<CurrencyTypes> WorldRaidTickets;
		public static readonly IEnumerable<CurrencyTypes> BILogCurrencyTypes;
		public Dictionary<CurrencyTypes, long> Values { get; set; }
		public Dictionary<CurrencyTypes, long> Tickets { get; }
		public Dictionary<CurrencyTypes, long> Property { get; }
		public long Gold { get; }
		public long Gem { get; }
		public long GemBonus { get; }
		public long GemPaid { get; }
		public long ActionPoint { get; }
		public long ArenaTicket { get; }
		public long RaidTicket { get; }
		public long WeekDungeonChaserATicket { get; }
		public long WeekDungeonChaserBTicket { get; }
		public long WeekDungeonChaserCTicket { get; }
		public long WeekDungeonFindGiftTicket { get; }
		public long WeekDungeonBloodTicket { get; }
		public long AcademyTicket { get; }
		public long SchoolDungeonATicket { get; }
		public long SchoolDungeonBTicket { get; }
		public long SchoolDungeonCTicket { get; }
		public long TimeAttackDungeonTicket { get; }
		public long MasterCoin { get; }
		public long WorldRaidTicketA { get; }
		public long WorldRaidTicketB { get; }
		public long WorldRaidTicketC { get; }
		public long ChaserTotalTicket { get; }
		public long SchoolDungeonTotalTicket { get; }
		public long EliminateTicketA { get; }
		public long EliminateTicketB { get; }
		public long EliminateTicketC { get; }
		public long EliminateTicketD { get; }
		public bool IsEmpty { get; }
		public bool Equals(CurrencyValue other)
		{
			return default;
		}

	}

	public enum ParcelChangeType
	{
		NoChange = 0,
		Terminated = 1,
		MailSend = 2,
		Converted = 3,
	}

	public abstract class BattleEntity : Entity, IEquatable<BattleEntity>
	{
		private EventHandler<BattleEntityDamagedEventArgs> Damaged;
		private EventHandler<PassiveTriggeredEventArgs> PassiveTriggered;
		public HashSet<SkillType> UntargetableExceptionSkillTypes;
		private HashSet<SkillType> ImmuneDamageBySkillTypes;
		protected DamageTransferEffectInfo CurrentDamageTransferEffect;
		protected HealConvertDamageEffectInfo CurrentHealConvertDamageEffect;
		private int costRegenBanEffectCount;
		public virtual TacticEntityType TacticEntityType { get; set; }
		public TacticRange TacticRange { get; set; }
		public SquadType SquadType { get; set; }
		public bool HasMainTarget { get; }
		public bool HasTarget { get; }
		public virtual EntityTargetContainer TargetContainer { get; }
		public EntityTargetFinder EntityTargetFinder { get; }
		public abstract bool Alive { get; }
		public abstract GroupTag GroupTag { get; }
		public string Name { get; set; }
		public Body2D Body { get; set; }
		public virtual Vector2 Position2D { get; }
		public virtual Vector2 Direction { get; set; }
		public int AIGroupId { get; set; }
		public float BodyRadius { get; }
		public virtual Vector3 PositionVisual { get; }
		public virtual GroundNode NearestGroundNode { get; set; }
		public abstract BehaviorType CurrentBehavior { get; set; }
		public abstract ActionState CurrentActionState { get; }
		public abstract HeroAction CurrentAction { get; set; }
		public virtual int Level { get; }
		public virtual int Grade { get; }
		public virtual long HitPoint { get; set; }
		public virtual long HitPointBefore { get; set; }
		public virtual long MaxHPCapGauge { get; set; }
		public virtual long MaxGaugeCapInHP { get; }
		public virtual long SummonedTime { get; set; }
		public virtual long MaxHitPoint { get; }
		public virtual BasisPoint HitPointRate { get; }
		public virtual long LostHitPoint { get; }
		public virtual ArmorType ArmorType { get; set; }
		public virtual long BattlePower { get; }
		protected BattleEntityStatProcessor statProcessor { get; set; }
		public virtual BattleEntityStat DefaultStat { get; }
		public virtual BattleEntityStat CurrentStat { get; }
		public virtual BattleEntityStat InitialStat { get; }
		public StackDamageProcessor StackDamageProcessor { get; }
		public AccumulateEffectProcessor AccumulateEffectProcessor { get; }
		public GaugeEffectProcessor GaugeEffectProcessor { get; }
		private List<Hash64> UntargetableExceptionLogicEffects { get; set; }
		public abstract bool HasCrowdControl { get; }
		public bool IsCostRegenBan { get; }
		protected ImmuneProcessor ImmuneProcessor { get; set; }
		public virtual IEnumerable<ExpirableObjectHolder<ImmuneEffect>> RuntimeImmunes { get; }
		public virtual DotProcessor DotProcessor { get; set; }
		public virtual List<ExpirableObjectHolder<DotAbility>> RuntimeDotAbilities { get; }
		public bool Equals(BattleEntity other)
		{
			return default;
		}

	}

	public class SkillSpecification
	{
		public string SkillGroupId { get; }
		public int SkillLevel { get; }
		public string SkillDataKey { get; }
		public string VisualDataKey { get; }
		public SkillSlot SkillSlot { get; }
		public SkillType SkillType { get; set; }
	}

	public struct Hash64 : IEquatable<Hash64>
	{
		public static readonly Hash64 Empty;
		public ulong Hash;
		public bool Equals(Hash64 other)
		{
			return default;
		}

	}

	public class DotAbility : IDispellable
	{
		public readonly IList<LogicEffectValue> LogicEffectValues;
		private HashSet<Hash64> LogicEffectTemplateHashes;
		private IList<AbilityModifier> abilityModifiers;
		public IList<DotAbility> AdditionalTicks;
		private long ApplyPeriodRate;
		private long PeriodMaxRate;
		private long PeriodMinRate;
		private bool useFixedStabilityRate;
		private BasisPoint fixedStabilityRate;
		public virtual string TemplateId { get; }
		public virtual Hash64 TemplateIdHash { get; }
		public virtual string LogicEffectGroupId { get; }
		public virtual LogicEffectCategory Category { get; }
		public SkillSpecification SkillSpecification { get; }
		public LogicEffectHitSpecification LogicEffectHitSpecification { get; }
		private long damageDistributeRate { get; }
		private int StartDelay { get; }
		public int Interval { get; set; }
		private int TotalCount { get; }
		public int Channel { get; }
		private IList<AbilityModifier> DamageModifiers { get; }
		private bool IsAdditionalTick { get; }
		private long AdditionalTickDamageRate { get; }
		public EndCondition EndCondition { get; }
		public int EndConditionArgument { get; }
		private int CurrentCount { get; set; }
		public LogicEffect LogicEffectToDispel { get; }
		public bool IsDispellable { get; }
		public Func<bool> ExpirationCheck { get; set; }
		public Entity ExpirationCheckOwner { get; set; }
		public int StackSameEffectCount { get; }
		public bool ExpireOldIfStackCountOver { get; }
	}

	public enum SkillType
	{
		None = 0,
		Ex = 1,
		Passive = 2,
		Leader = 3,
		Normal = 4,
		ExtraPassive = 5,
		Public = 6,
		GroupBuff = 8,
		HexaBuff = 9,
		EventBuff = 10,
		TimeAttackGeasPassive = 11,
		HiddenPassive = 12,
	}

	public abstract class SkillCard : IDisposable
	{
		private EventHandler<EventArgs> StateChanged;
		private static int SkillUniqueIndex;
		public int SkillCardUniqueId;
		public int Cost;
		public int ExtraCost;
		public int EnemyCost;
		public int ExtraEnemyCost;
		public int NPCCost;
		public int ExtraNPCCost;
		public abstract BattleEntity OwnerEntity { get; }
		public abstract long OwnerCostumeId { get; }
		public SkillDataPack SkillData { get; }
		public string SkillGroupId { get; }
		public CharacterSkillListKey SkillListKey { get; set; }
		public int SkillLevel { get; }
		public int ActiveGauge { get; }
		public SkillSlot SkillSlot { get; }
		public int CoolTime { get; set; }
		public int RemainCoolTime { get; set; }
		public abstract TargetCandidateRule CandidateRule { get; }
		public abstract TargetSortRule SortRule { get; }
		public SkillCardState State { get; set; }
		public int HandIndex { get; set; }
		public Vector3 InputPosition { get; set; }
		public Vector3 GuidePosition { get; set; }
		public Vector3 GuideDirection { get; set; }
		public IList<BattleEntity> SelectTargets { get; set; }
		public bool AutoTargeting { get; set; }
		public bool IsAutoUse { get; set; }
		public abstract EntityId OwnerEntityId { get; }
		public abstract long CharacterId { get; }
		public int OriginalCost { get; }
		public int CostUsed { get; set; }
		public bool IsNPCCard { get; set; }
		public int SkillRemainCount { get; set; }
		public void Dispose()
		{
		}

	}

	public abstract class Shape
	{
		public abstract ShapeType ShapeType { get; }
		public abstract Vector2 Center { get; set; }
		public abstract ValueTuple<float, float> Size { get; }
		public virtual Vector2 Forward { get; set; }
		public virtual Vector2 Right { get; set; }
	}

	public interface ICustomParticleEvent
	{
	}

	public interface IDispellable
	{
		public abstract string TemplateId { get; }
		public abstract string LogicEffectGroupId { get; }
		public abstract LogicEffectCategory Category { get; }
		//public virtual Hash64 TemplateIdHash { get; }
	}

	public enum ResolvePriority
	{
		Dispel = 0,
		StatChange = 1,
		LifeGain = 2,
		StatusRemove = 3,
		Normal = 4,
		CrowdControlStatusAdd = 5,
		StatusAdd = 6,
		Damage = 7,
	}

	public class LogicEffectHitSpecification
	{
		public string SkillEntityName;
		public LogicEffectValue LogicEffectValue;
		public BattleEntity Invoker;
		public BattleEntity Target;
		public BattleEntity OriginalTarget;
		public Vector2 HitPosition;
		public Vector2 BulletPosition;
		public Vector2 BulletDirection;
		public Entity BulletEntity;
		public int ExtraCostUsed;
	}

	public abstract class Entity
	{
		public List<string> ConditionIdList;
		public List<string> CommandIdList;
		public virtual EntityId EntityId { get; set; }
		public bool Active { get; set; }
	}

	public class ManualSkillProcessor
	{
		private BattleEntity Executer { get; }
		private List<ManualSkill> groupBuffs { get; }
		private List<ManualSkill> hexaBuffs { get; }
		private List<EventSkill> eventBuffs { get; }
	}

	public class PlayerSkillCardManager : CostSkillCardManager
	{
		private EventHandler<SkillCardEventArgs> SkillCardStateChanged;
		private int blockAutoUseTemporarilyCount;
		public override SkillPriorityCheckTarget FeverTarget { get; }
		public HandSlot[] Hand { get; set; }
		public HandSlot TSSSlot { get; set; }
		public SkillCard TSSSkillCard { get; set; }
		public bool IsAutoUseSettingTrue { get; set; }
		public bool IsAutoUse { get; }
		public int AutoUseIndex { get; set; }
		public bool IsBulletTime { get; set; }
		public int LastSkillUseIndex { get; set; }
		public bool IsAutoUseSummonTSS { get; set; }
		protected Queue<SkillCard> TopSkillCards { get; set; }
		public PlayerGroup PlayerGroup { get; set; }
		public override float CurrentFrameUsableCost { get; }
	}

	public interface IEntityBody
	{
	}

	public abstract class AreaEntityValue : SkillEntityValue, ICancelableBySkill
	{
		public bool AttachEntity { get; }
		public bool AllowDuplicateHit { get; }
		public int Duration { get; }
		public bool RotateEntityDirectionEveryFrame { get; }
		public bool ApplyOffsetRotateEntityDirection { get; }
		public IList<int> HitFrames { get; }
		public bool RemoveEntityIfSkillCancel { get; }
		public Nullable<AreaCollisionProperty> CollisionProperty { get; }
		public bool CheckBlockHit { get; }
		public IList<SkillAbilityValue> AreaAbilities { get; }
		public string HitCheckCouplingKey { get; }
		public MovingAreaOptions MovingAreaOption { get; }
		public bool IsRemoveEntityIfSkillCancel()
		{
			return default;
		}

	}

	[Serializable]
	public struct AreaCollisionProperty : IEquatable<AreaCollisionProperty>, IMemoryPackable<AreaCollisionProperty>, IMemoryPackFormatterRegister
	{
		public static readonly AreaCollisionProperty Empty;
		public AreaTransformTypes TransformType;
		public int TransformCount;
		public bool Equals(AreaCollisionProperty other)
		{
			return default;
		}

	}

	public class Body2D
	{
		private DirectionRotator dirRotator;
		private Vector2 acceleration;
		private Vector2 velocity;
		public Func<int> getCurrentFrameFunc;
		private int lastPreviousBondingCircleUpdateFrame;
		private Vector2 lastWarpByPlatformPosition;
		private int lastWarpByPlatformFrame;
		public float BodyRadius { get; }
		public Vector2 Forward { get; set; }
		public Vector2 Right { get; }
		public Vector2 Position2D { get; set; }
		public Vector2 Velocity { get; set; }
		public int CurrentFrame { get; }
		public float CurrentSpeed { get; set; }
		public float MaxSpeed { get; set; }
		public float MaxAngularVelocity { get; set; }
		private float mass { get; }
		private float inverseMass { get; }
		public Shape Collision { get; set; }
		public Vector2 CollisionPositionOffset { get; set; }
		private float collisionAngleDistance { get; }
		private bool IsContinousMoving { get; }
		private Circle PreviousBoundingCircle { get; }
		private Circle CurrentBoundingCircle { get; }
	}

	public class HitCheckCoupling
	{
		private Dictionary<int, HashSet<BattleEntity>> hitEntityTable;
	}

	public enum MovingAreaOptions
	{
		None = 0,
		FixedAim = 1,
		CheckSpawnPositionOutOfMovingArea = 2,
	}

	public enum BattleEntityType
	{
		None = 0,
		Character = 16777216,
		SkillActor = 33554432,
		Obstacle = 67108864,
		Point = 134217728,
		Projectile = 268435456,
		EffectArea = 536870912,
		Supporter = 1073741824,
		BattleItem = -2147483648,
	}

	public class BattleItemEntityValue : SummonEntityValue
	{
		public float RecognitionRadius { get; }
		public float EffectRadius { get; }
		public int TargetCount { get; }
		public int ActiveDelayInFrame { get; }
		public IList<LogicEffectValue> LogicEffectValues { get; }
		public IList<SkillAbilityValue> Abilities { get; }
		public Dictionary<int, List<SkillAbilityValue>> OrderToAbilityTable { get; }
		public AreaSpawnerValue InEffectRadusAreaSpawnerEntityValue { get; }
		public SkillEntitySpawnerValue InEffectRadiusSkillEntitySpawnerEntityValue { get; }
	}

	public class Circle : Shape, IEquatable<Circle>
	{
		public static Circle Empty { get; }
		public static Circle Default { get; }
	
		[JsonIgnore]
		public override ShapeType ShapeType { get; }
	
		[JsonIgnore]
		public override ValueTuple<float, float> Size { get; }
		public override Vector2 Center { get; set; }
		public float Radius { get; set; }
		public bool Equals(Circle other)
		{
			return default;
		}

	}

	public enum BehaviorType
	{
		None = 0,
		NormalAttack01 = 1,
		NormalAttack02 = 2,
		NormalAttack03 = 3,
		NormalAttack04 = 4,
		NormalAttack05 = 5,
		NormalAttack06 = 6,
		NormalAttack07 = 7,
		NormalAttack08 = 8,
		NormalAttack09 = 9,
		NormalAttack10 = 10,
		UseExSkill01 = 11,
		UseExSkill02 = 12,
		UseExSkill03 = 13,
		UseExSkill04 = 14,
		UseExSkill05 = 15,
		UseExSkill06 = 16,
		UseExSkill07 = 17,
		UseExSkill08 = 18,
		UseExSkill09 = 19,
		UseExSkill10 = 20,
		UsePublicSkill01 = 21,
		UsePublicSkill02 = 22,
		UsePublicSkill03 = 23,
		UsePublicSkill04 = 24,
		UsePublicSkill05 = 25,
		UsePublicSkill06 = 26,
		UsePublicSkill07 = 27,
		UsePublicSkill08 = 28,
		UsePublicSkill09 = 29,
		UsePublicSkill10 = 30,
		Dead = 50,
		Dying = 51,
		Retreat = 52,
		EnterGround = 53,
		TSSInteract = 54,
		Idle = 55,
		Stunned = 100,
		Hit = 101,
		Knockback = 102,
		Panic = 103,
		Paralysis = 104,
		Emp = 105,
		Purify = 106,
		Groggy = 107,
		GroggyDead = 108,
		Frozen = 109,
		Move = 200,
		MoveToFormationBeacon = 201,
		MoveLeft = 202,
		MoveRight = 203,
		MoveAttack = 204,
		ReleaseFormConversion = 205,
		Walk = 300,
		Stop = 301,
		Seek = 302,
		Flee = 303,
		Evade = 304,
		Wander = 305,
		SeekPosition = 306,
		Feared = 307,
		Airborn = 308,
		Charmed = 309,
		Pulling = 310,
		Stasis = 311,
		Following = 312,
		MetamorphNormalAttack01 = 313,
	}

	public enum ActionState
	{
		Default = 0,
		Phase01 = 1,
		Phase02 = 2,
		Phase03 = 3,
		Phase04 = 4,
		Phase05 = 5,
		Phase06 = 6,
		Phase07 = 7,
		Phase08 = 8,
		Phase09 = 9,
		None = 10,
	}

	public abstract class HeroAction : IEquatable<HeroAction>
	{
		private EventHandler<EventArgs> Started;
		private EventHandler<EventArgs> Finished;
		private EventHandler<EventArgs> Interrupted;
		private EventHandler<EventArgs> ActionStateChanged;
		private int elapsed;
		private int duration;
		private ActionState actionState;
		public BehaviorType BehaviorType { get; }
		public BattleEntity Executer { get; }
		protected EntityId ExecuterId { get; }
		public bool IsLocking { get; set; }
		public int Elapsed { get; set; }
		public int Duration { get; set; }
		public ActionState ActionState { get; set; }
		public virtual ActionProgress ActionProgress { get; }
		public bool Equals(HeroAction other)
		{
			return default;
		}

	}

	public interface IEntitySpawnable
	{
		public abstract SkillSpecification SkillSpecification { get; }
		public abstract int ExtraCostUsed { get; }
		public abstract BattleEntity Executer { get; }
	}

	public class ProjectileEventArgs : EventArgs
	{
		public EntityId ProjectileId { get; }
		public Vector2 CollidedPosition { get; }
		public EntityId TargetId { get; }
		public EntityId ObstacleId { get; }
	}

	public sealed class MoveProjectileDelegate
	{
	}

	public abstract class ProjectileEntityValue : SkillEntityValue
	{
		public SpawnPositionTypes DestinationType { get; }
		public Vector2 DestinationWorldPosition { get; }
		public Vector2 DestinationPositionOffset { get; }
		public int DestinationPositionRandomOffsetRange { get; }
		public SpawnDirectionTypes DestinationOffsetDirectionType { get; }
		public ProjectileTypes ProjectileType { get; }
		public ShapeType ShapeType { get; }
		public float Width { get; }
		public float Height { get; }
		public int FireDelayFrame { get; }
		public float Speed { get; }
		public long FrameToHit { get; }
		public bool IsStickToTargetAfterHit { get; }
		public IList<SkillAbilityValue> Abilities { get; }
		public int SplashDelay { get; }
		public AreaEntityValue SplashEntityData { get; }
		public AreaSpawnerValue SplashSpawner { get; }
		public SkillEntitySpawnerValue SkillEntitySpawner { get; }
	}

	[Serializable]
	public struct TargetCandidateRule : IEquatable<TargetCandidateRule>
	{
		public static readonly TargetCandidateRule Invalid;
		public bool IsValid { get; }
		public TargetingType TargetingType { get; }
		public TargetEntityType ApplyEntityType { get; }
		public int MaxCount { get; }
		public TargetSideId TargetSide { get; }
		public AliveState AliveState { get; }
		public SchoolConstraint SchoolConstraint { get; }
		public WeaponConstraint WeaponConstraint { get; }
		public SquadTypeConstraint SquadTypeConstraint { get; }
		public AdaptationConstraint AdaptationConstraint { get; }
		public BulletConstraint BulletConstraint { get; }
		public TacticRangeConstraint TacticRangeConstraint { get; }
		public TagConstraint TagConstraint { get; }
		public HPRateConstraint HPRateConstraint { get; }
		public TacticRoleConstraint TacticRoleConstraint { get; }
		public CoverState CoverState { get; }
		public bool NeedSearchTarget { get; }
		public bool Equals(TargetCandidateRule other)
		{
			return default;
		}

	}

	[Serializable]
	public struct TargetSortRule : IEquatable<TargetSortRule>, IMemoryPackable<TargetSortRule>, IMemoryPackFormatterRegister
	{
		public static readonly TargetSortRule Empty;
		public TargetSortCriteria SortCriteria;
		public StatType SortStat;
		public string SortParameter;
		public TargetSortOrder OrderBy;
		[JsonIgnore]
		public List<Hash64> SortParameterHashes;
	
		[JsonIgnore]
		public bool IsValid { get; }
	
		[JsonIgnore]
		public bool RandomTargetSelect { get; }
		public bool Equals(TargetSortRule other)
		{
			return default;
		}

	}

	public abstract class SkillEntityValue
	{
		public string EntityName { get; }
		public long SpawnRate { get; }
		public long SpawnDelay { get; }
		public string LogicName { get; }
		public SkillApplyType ApplyType { get; }
		public TransformDecideTiming DecideTiming { get; }
		public bool EntitySpawnIncludeOutOfRangeInputTarget { get; }
		public SpawnPositionTypes SpawnPositionType { get; }
		public Vector2 SpawnWorldPosition { get; }
		public Vector2 PositionOffset { get; }
		public int PositionRandomOffsetRange { get; }
		public SpawnDirectionTypes OffsetDirectionType { get; }
		public SpawnDirectionTypes SpawnDirectionType { get; }
		public TargetSortRule TargetSortRule { get; }
		public TargetCandidateRule TargetCandidateRule { get; }
		public bool UsePrimaryTargetingRule { get; }
		public long DamageDistributeRate { get; set; }
		public bool CheckSpawnPositionMovable { get; set; }
	}

	public class BeamEntityValue : SkillEntityValue
	{
		public bool RemoveEntityIfSkillCancel;
		public SpawnPositionTypes DestinationType { get; }
		public Vector2 DestinationWorldPosition { get; }
		public Vector2 DestinationPositionOffset { get; }
		public int DestinationPositionRandomOffsetRange { get; }
		public SpawnDirectionTypes DestinationOffsetDirectionType { get; }
		public float ObbWidth { get; }
		public long ExpansionDuration { get; }
		public long KeepingDuration { get; }
		public long ExtinctionDuration { get; }
		public long ExtinctionHeadRate { get; }
		public long ExtinctionTailRate { get; }
		public bool Piercing { get; }
		public bool FollowSpawnEntity { get; }
		public bool FollowTargetEntity { get; }
		public bool ApplyAbilityOnlyTarget { get; }
		public int ApplyAbilityToHitTargetMaxCount { get; }
		public List<BeamAbilityFrameValue> IntervalAbilities { get; }
		public List<BeamAbilityFrameValue> TimelineAbilities { get; }
		public List<BeamSplashValue> Splashes { get; }
		public List<ChainBeamValue> ChainBeams { get; }
	}

	public enum BeamPhase
	{
		Expansion = 0,
		Keeping = 1,
		Extinction = 2,
	}

	public abstract class AuraEntityValue : SkillEntityValue, ICancelableBySkill
	{
		public bool RemoveEntityIfAttachSpawnTargetDie;
		public bool AttachSpawnTarget { get; }
		public bool RotateEntityDirectionEveryFrame { get; }
		public bool ApplyOffsetRotateEntityDirection { get; }
		public int Duration { get; }
		public int Interval { get; }
		public SameAuraCheckCondition RemoveEntityIfSameEntitySpawn { get; }
		public bool RemoveEntityIfSkillCancel { get; }
		public MovingAreaOptions MovingAreaOption { get; }
		public IList<SkillAbilityValue> AreaAbilities { get; }
		public bool IsRemoveEntityIfSkillCancel()
		{
			return default;
		}

	}

	public class NormalAttackDelivererEventArgs : EventArgs
	{
		public string EntityName { get; }
		public Vector2 CollidedPosition { get; set; }
		public BattleEntity Target { get; set; }
		public BattleEntity OriginalTargetWhenHitObstacle { get; set; }
	}

	public interface IObstacle
	{
		public abstract bool IsDestroyed { get; set; }
		public abstract ObstacleCoverType ObstacleCoverType { get; }
		public abstract EntityMaterialType MaterialType { get; }
		public abstract ObstacleHeightType ObstacleHeight { get; }
		public abstract CoverMotionType CoverMotionType { get; }
		public abstract BattleEntityStatProcessor StatProcessor { get; }
		public abstract BattleEntity Entity { get; }
		public abstract bool IsOccupied { get; }
		public abstract bool Alive { get; }
		public abstract BasisPoint HitPointRate { get; }
		public abstract long HitPoint { get; }
		public abstract long MaxHitPoint { get; }
		public abstract float LifeTimeRate { get; }
	}

	public class NormalAttackBulletEntityValue : TargetSkillEntityValue
	{
		public long Speed { get; }
	}

	public enum SkillApplyType
	{
		None = 0,
		Direct = 2,
		Hitscan = 4,
		AlwaysBlocked = 5,
	}

	public interface IHitCheckCouplingProvider
	{
	}

	public class ObstaclePoint : IEquatable<ObstaclePoint>
	{
		public GroundNode GroundNode;
		public Vector2 Position2D;
		public float PositionHeight;
		public Vector3 PositionVisual { get; }
		public bool Equals(ObstaclePoint other)
		{
			return default;
		}

	}

	[Serializable]
	public class GroundObstacleData : IEquatable<GroundObstacleData>, IMemoryPackable<GroundObstacleData>, IMemoryPackFormatterRegister
	{
		public Vector2 Scale;
		public Vector2 Offset;
		public Vector2 Size;
		public float PreDuration;
		public float DestroyDuration;
		public float RetreatDuration;
		public float RemainTime;
		public bool JumpAble;
		public bool Indestructible;
		public bool CrashByTSS;
		public ObstacleHeightType ObstacleHeightType;
		public ObstacleDestroyType DestroyType;
		public ObstacleDestroyType RetreatType;
		public ArmorType ArmorType;
		public ObstacleCoverType ObstacleCoverType;
		public CoverMotionType CoverMotionType;
		public EntityMaterialType MaterialType;
		public string UniqueName;
		public uint NameHash;
		public Vector2 Direction;
		public List<Vector2> EnemyPoints;
		public List<Vector2> PlayerPoints;
		public bool Equals(GroundObstacleData other)
		{
			return default;
		}

	}

	public struct ObstacleStatExcel
	{
		private Table __p;
		public ByteBuffer ByteBuffer { get; }
		public uint StringID { get; }
		public string Name { get; }
		public long MaxHP1 { get; }
		public long MaxHP100 { get; }
		public long BlockRate { get; }
		public long Dodge { get; }
		public long CanNotStandRange { get; }
		public float HighlightFloaterHeight { get; }
		public long EnhanceLightArmorRate { get; }
		public long EnhanceHeavyArmorRate { get; }
		public long EnhanceUnarmedRate { get; }
		public long EnhanceElasticArmorRate { get; }
		public long EnhanceStructureRate { get; }
		public long EnhanceNormalArmorRate { get; }
		public long ReduceExDamagedRate { get; }
	}

	public class OBB : Shape, IEquatable<OBB>
	{
		private Vector2 center;
		private float rightAngleInRadian;
		private Vector2[] axis;
		public static OBB Empty { get; }
	
		[JsonIgnore]
		public override ShapeType ShapeType { get; }
	
		[JsonIgnore]
		public override ValueTuple<float, float> Size { get; }
		public override Vector2 Center { get; set; }
		public float Width { get; }
		public float Height { get; }
		private float CircumcircleRadius { get; set; }
	
		[JsonIgnore]
		private Vector2 HalfWidths { get; }
	
		[JsonIgnore]
		private float RightAngle { get; }
	
		[JsonIgnore]
		public override Vector2 Forward { get; set; }
	
		[JsonIgnore]
		public override Vector2 Right { get; set; }
		public Circle CircumCircle { get; set; }
	
		[JsonIgnore]
		public Vector2 TopLeft { get; }
	
		[JsonIgnore]
		public Vector2 TopRight { get; }
	
		[JsonIgnore]
		public Vector2 BottomLeft { get; }
	
		[JsonIgnore]
		public Vector2 BottomRight { get; }
		public bool Equals(OBB other)
		{
			return default;
		}

	}

	public enum ObstacleState
	{
		Pre = 0,
		Idle = 1,
		Destroy = 2,
		Retreat = 3,
		Remain = 4,
		Remove = 5,
	}

	public class ObstacleSaveData
	{
		public string UniqueName;
		public Vector3 Position;
		public Vector3 Forward;
		public List<int> ActiveEnemyPointIndices;
		public List<int> ActivePlayerPointIndices;
		public List<string> ConditionIdList;
		public List<string> CommandIdList;
		public List<ObstacleSaveData> SubObstacles;
		public bool IsDummy;
	}

	public class BattleEntityStatProcessor
	{
		private Dictionary<StatType, List<StatChangeEffect>> defaultStatChangeEffects;
		private Dictionary<StatType, List<StatChangeEffect>> effectsTable;
		private BattleEntity owner;
		private HashSet<StatType> runtimeDirtyStats;
		private HashSet<StatType> addedStats;
		private long lastMaxHP;
		private List<StatChangeEffect> lastMaxHPEffectList;
		public long BattlePower { get; set; }
		public BattleEntityStat DefaultStat { get; set; }
		public BattleEntityStat InitialStat { get; set; }
		public BattleEntityStat CurrentStat { get; set; }
		public List<ExpirableObjectHolder<StatChangeEffect>> RuntimeEffects { get; }
	}

	public class AreaSpawner : SpawningEntity
	{
		private bool isDirectionSet;
		private Nullable<Vector2> Direction;
		private IList<BattleEntity> primaryTargets;
		private Vector2 position;
		private Vector2 randomPosition;
		private long ownerSkillRange;
		private Dictionary<string, Vector2> skillEntityPositionTable;
		private Dictionary<string, Vector2> skillEntityDirectionTable;
		private AreaSpawnerValue spawnerValue { get; }
		private List<ValueTuple<int, Hash64, AreaEntityValue>> EntityTimeline { get; }
		private Dictionary<string, List<BattleEntity>> skillEntityTargetTable { get; set; }
	}

	public class LineSegment : Shape, IEquatable<LineSegment>
	{
		public static LineSegment Invalid { get; }
	
		[JsonIgnore]
		public override ShapeType ShapeType { get; }
	
		[JsonIgnore]
		public override ValueTuple<float, float> Size { get; }
		public Vector2 Origin { get; set; }
		public Vector2 Dest { get; set; }
	
		[JsonIgnore]
		public Vector2 ToDest { get; }
		public override Vector2 Forward { get; set; }
		public override Vector2 Right { get; set; }
	
		[JsonIgnore]
		public override Vector2 Center { get; set; }
	
		[JsonIgnore]
		public float Length { get; }
	
		[JsonIgnore]
		public float LengthSquared { get; }
		public bool Equals(LineSegment other)
		{
			return default;
		}

	}

	public class StatusProcessor
	{
		public IEnumerable<ExpirableObjectHolder<StatusResult>> RuntimeStatus { get; }
		private List<ExpirableObjectHolder<StatusResult>> runningStatusList { get; }
		public int CrowdControlCount { get; set; }
		public int CrowdControlDuration { get; set; }
		public bool HasCrowdControl { get; }
		public HeroStatus ForceActionStatus { get; }
		public HashSet<HeroStatus> StatusSet { get; }
		private List<HeroStatus> permanentStatusList { get; }
		private List<StatusParams> addedStatus { get; }
		private List<StatusResult> markRemoveList { get; }
		private List<HeroStatus> expiredList { get; }
		private Character owner { get; }
		private StatusComparer comparer { get; }
		private Dictionary<HeroStatus, StatusExecution> statusExecutionTable { get; }
	}

	public interface IHeroSummarizable
	{
		public abstract HeroSummaryDetailFlag SummaryDetail { get; }
	}

	public interface ICharacter
	{
		public abstract long ServerId { get; }
		public abstract long OwnerAccountId { get; }
		public abstract long CharacterId { get; }
		public abstract long CostumeId { get; }
		public abstract long CharacterSkillListGroupId { get; }
		public abstract long PersonalityId { get; }
		public abstract bool IsNPC { get; }
		public abstract TacticEntityType TacticEntityType { get; }
		public abstract BulletType BulletType { get; }
		public abstract School School { get; }
		public abstract int FavorRank { get; set; }
		public abstract Battle BattleCache { get; }
		public abstract CharacterGroup CharacterGroup { get; }
		public abstract BattleEntityStatProcessor StatProcessor { get; }
		public abstract DotProcessor DotProcessor { get; }
		public abstract IList<Equipment> Equipments { get; }
		public abstract WeaponSetting WeaponSetting { get; }
		public abstract GearSetting GearSetting { get; }
		public abstract CostumeSetting CostumeSetting { get; }
		public abstract bool CheckCanUseAutoPublicSkill { get; }
		public abstract Dictionary<StatType, int> PotentialStatLevelDict { get; set; }
		public abstract EntityId EntityId { get; }
		public abstract EntityTargetContainer TargetContainer { get; }
		public abstract Vector2 Position2D { get; }
		public abstract Vector2 Direction { get; set; }
		public abstract Vector3 PositionVisual { get; }
		public abstract GroundNode NearestGroundNode { get; }
		public abstract BehaviorType CurrentBehavior { get; set; }
		public abstract ActionState CurrentActionState { get; }
		public abstract HeroAction CurrentAction { get; }
		public abstract int Level { get; }
		public abstract int Grade { get; }
		public abstract long HitPoint { get; }
		public abstract long HitPointBefore { get; }
		public abstract long MaxHPCapGauge { get; set; }
		public abstract long MaxGaugeCapInHP { get; }
		public abstract long SummonedTime { get; }
		public abstract long MaxHitPoint { get; }
		public abstract BasisPoint HitPointRate { get; }
		public abstract long LostHitPoint { get; }
		public abstract ArmorType ArmorType { get; }
		public abstract long BattlePower { get; }
		public abstract BattleEntityStat DefaultStat { get; }
		public abstract BattleEntityStat CurrentStat { get; }
		public abstract BattleEntityStat InitialStat { get; }
		public abstract IEnumerable<ExpirableObjectHolder<ImmuneEffect>> RuntimeImmunes { get; }
		public abstract List<ExpirableObjectHolder<DotAbility>> RuntimeDotAbilities { get; }
	}

	public class ActionChangedEventArgs : EventArgs
	{
		public EntityId EntityId { get; }
		public BehaviorType Behavior { get; }
		public ActionState ActionState { get; }
		public bool IsActionStartedEvent { get; }
	}

	public class StatusAddedEventArgs : EventArgs
	{
		public EntityId EntityId { get; }
		public EntityId InvokerId { get; }
		public SkillSpecification SkillSpecification { get; }
		public HeroStatus Status { get; }
		public int Duration { get; }
		public bool IsCrowdControl { get; }
		public ForceMoveParams ForceMove { get; }
	}

	public class StatusRemovedEventArgs : EventArgs
	{
		public EntityId EntityId { get; set; }
		public HeroStatus Status { get; set; }
	}

	public class StatusResistEventArgs : EventArgs
	{
		public EntityId EntityId { get; }
		public bool HasImmune { get; }
		public bool ForceFloaterHide { get; set; }
	}

	public class ImmuneAddedEventArgs : EventArgs
	{
		public EntityId EntityId { get; }
		public EntityId InvokerId { get; }
		public string ImmunTemplateId { get; }
	}

	public class ImmuneRemovedEventArgs : EventArgs
	{
		public string ImmuneTemplateId { get; set; }
		public EntityId EntityId { get; set; }
	}

	public class CharacterBulletCountChangedEventArgs : EventArgs
	{
		public EntityId EntityId { get; }
		public long PreviousCount { get; }
		public long CurrentCount { get; }
	}

	public class CoverStateChangedEventArgs : EventArgs
	{
		public EntityId CharacterId { get; }
		public EntityId ObstacleId { get; }
		public CoverState ChangedState { get; }
	}

	public class SkillActionRegisteredEventArgs : EventArgs
	{
		public HeroAction SkillAction { get; }
	}

	public class ImmediateKillEffect : LogicEffect
	{
		private ImmediateKillEffectValue value { get; }
		public bool IgnoreImmortal { get; }
		public bool IgnoreAppliedCheat { get; }
	}

	public struct StatusResult : IComparable<StatusResult>, IEquatable<StatusResult>, IDispellable
	{
		private readonly string templateId;
		public readonly Hash64 TemplateIdHash;
		public BattleEntity Invoker { get; }
		public HeroStatus Status { get; }
		public SkillSpecification SkillSpecification { get; }
		public bool IsCrowdControl { get; }
		public uint VisualIdHash { get; }
		public string LogicEffectGroupId { get; }
		public string TemplateId { get; }
		public LogicEffectCategory Category { get; }
		public bool Dispellable { get; }
		public string SkillEntityName { get; }
		public Func<bool> ExpirationCheck { get; }
		public bool IsDurationChangedByStat { get; }
		public int CompareTo(StatusResult other)
		{
			return default;
		}

		public bool Equals(StatusResult other)
		{
			return default;
		}

	}

	public class MoveToWorldPositionCommand
	{
		public bool IsLeft { get; }
		public Vector2 TargetPosition { get; }
	}

	public class DebuffEventArgs : EventArgs
	{
		public EntityId InvokerId { get; }
		public string LogicEffectGroupId { get; }
		public string LogicEffectTemplateId { get; }
		public int Level { get; }
		public int DurationFrame { get; }
		public SkillSpecification SkillSpecification { get; }
	}

	public class PositioningSetting
	{
		public readonly float FormationPositionReduceRatio;
		public readonly float FormationPositionReduce;
		public readonly float ObstaclePositionReduceRatio;
		public readonly float ObstaclePositionReduce;
		private long positioningGapCentimeter;
		public readonly PositioningType PositioningType;
		public float PositioningGapSqr { get; set; }
		public float PositioningGap { get; set; }
	}

	public class SkillProcessor
	{
		private Dictionary<ValueTuple<SkillSlot, CharacterSkillListKey>, SkillDataPack> skillTable;
		private HashSet<ExpirableObjectHolder<ModifySkillEffect>> expirableEffects;
		private Dictionary<ValueTuple<SkillSlot, CharacterSkillListKey>, AutoUseCheck> AutoUseCheckTable;
		public HashSet<SkillSlot> AutoUseDisabledSkillList;
		public IDictionary<ValueTuple<SkillSlot, CharacterSkillListKey>, SkillDataPack> SkillTable { get; }
	}

	public class PassiveSkillProcessor
	{
		private readonly BattleEntity owner;
		private Dictionary<PassiveSkill, List<PassiveExecution>> skillExecutionsTable;
		private ICollection<PassiveSkill> skills { get; }
		private List<BattleEntity> watchTargets { get; }
	}

	public class BehaviorTree
	{
		public RootSelector Root { get; set; }
		public BehaviorResult Result { get; set; }
	}

	public enum CoverState
	{
		None = 0,
		NotCovered = 1,
		Covered = 2,
	}

	public class AppearSetting
	{
		public bool IsApearActionOn;
		public List<SpawnMovePoint> MovePoints;
	}

	public class PathFinder
	{
		private GroundNodeType passableNodeType;
		private bool checkTSSBlocked;
		private ObstaclePosition obstacleToAttackTarget;
		private GroundNode lastTargetPosition;
		private GroundNode lastOwnerPosition;
		private bool isObstacleChanged;
		private bool isNeedToFindAnotherObstacle;
		private Character characterAtLastGroundNode;
		private readonly bool isFireLineCheckMyObstacle;
		private readonly bool isFireLineCheckAllyObstacle;
		private readonly bool isFireLineCheckEnemyObstacle;
		private readonly bool isFireLineCheckEmptyObstacle;
		private LastFailedPathInfo lastFailedPathInfo;
		private HashSet<ValueTuple<GroundNode, GroundNode, IObstacle>> lineOfFireFailed;
		private Battle Battle { get; }
		private CharacterGroup OwnerCharacterGroup { get; }
		private Character Owner { get; }
		private BattleEntity TargetBattleEntity { get; }
		private TargetingType TargetingType { get; }
		private Vector2 TargetPosition { get; }
		public bool IsPathUsed { get; set; }
		public bool IsUseInitialRangeRate { get; set; }
		public bool IsTargetOnLineOfFire { get; }
		private bool IsRefreshPathToTargetRequired { get; }
		private List<GroundNode> pathToAttackTarget { get; set; }
		public IEnumerable<GroundNode> PathToAttackTarget { get; }
		public ObstaclePosition ObstacleToAttackTarget { get; }
	}

	public class ForceMoveCommandInfo
	{
		public const int PrioritySkill = 0;
		public const int PriorityGroundCommand = 1;
		private GroundNode targetNode;
		private Battle battle;
		protected bool isNeedToUpdatePathList;
		private List<GroundNode> pathList;
		public int Priority { get; }
		public bool IsTargetPointFormationBeacon { get; }
		public virtual GroundNode TargetNode { get; }
		public bool IsInstantMove { get; }
		public bool IsInterruptCurrentAction { get; }
		public Vector2 PositionOffset { get; }
		public bool KeepRelativePosition { get; }
		public bool IsCommandByBattleItem { get; }
	}

	public class ForceHoldCommandInfo
	{
		public bool Activated { get; set; }
		public bool AllowBattleItemMove { get; }
	}

	public class SkillCommandInfo
	{
		public bool AutoTargeting;
		public BattleEntity TargetBattleEntity;
		public Vector2 TargetPosition2D;
		public Vector2 TargetDirection2D;
		public SkillSlot SkillToUse;
	}

	public enum TSAInteractionState
	{
		NotInteracting = 0,
		Interacting = 1,
		TSADying = 2,
	}

	public struct WeaponSetting : IEquatable<WeaponSetting>
	{
		public const int InvalidId = -1;
	
		[JsonIgnore]
		public bool IsValid { get; }
		public long UniqueId { get; set; }
		public int StarGrade { get; set; }
		public int Level { get; set; }
		public bool Equals(WeaponSetting other)
		{
			return default;
		}

	}

	public struct GearSetting : IEquatable<GearSetting>
	{
		public const int InvalidId = -1;
	
		[JsonIgnore]
		public bool IsValid { get; }
		public long UniqueId { get; set; }
		public int Tier { get; set; }
		public int Level { get; set; }
		public bool Equals(GearSetting other)
		{
			return default;
		}

	}

	public struct CostumeSetting : IEquatable<CostumeSetting>
	{
		public const int InvalidId = 0;
	
		[JsonIgnore]
		public bool IsValid { get; }
		public long UniqueId { get; set; }
		public bool Equals(CostumeSetting other)
		{
			return default;
		}

	}

	public class CharacterFormRootMotion
	{
		public RootMotionFrame PublicSkill;
		public RootMotionFrame MoveEndNormal;
		public RootMotionFrame MoveEndKneel;
		public RootMotionFrame MoveEndStand;
	}

	public class RootMotionFrame
	{
		public int Duration { get; }
		public float PositionMagnitudeForward { get; set; }
		public Vector2[] PositionDeltas { get; set; }
	}

	public class FormConversionInfo : LogicEffectExpireChecker
	{
		public int FormIndex { get; }
		public int Channel { get; }
		public bool ReleaseFormConversionRequired { get; set; }
		public bool ReleaseFormConversionFinished { get; set; }
		public int ReleaseFormConversionDuration { get; }
		public bool DisableUseSkill { get; }
		public bool ExSkillCardRedrawInHand { get; }
		public ExpirableObjectHolder<DotAbility> Effect { get; }
	}

	public class CharacterSkillListKey
	{
		public int FormIndex { get; set; }
		public long TSAInteractionId { get; set; }
		public static CharacterSkillListKey Default { get; }
	}

	public class ShieldInfo
	{
		private IEnumerator conditionChecker;
		public int Channel { get; }
		public long CurrentHP { get; set; }
		public long MaxHP { get; }
		public SkillSpecification SkillSpecification { get; }
		private ExpirableObjectHolder<DotAbility> DotAbility { get; }
		private ShieldEffect ShieldEffect { get; }
		private Character owner { get; }
	}

	public class TemporaryHpInfo
	{
		private IEnumerator conditionChecker;
		private int elapsed;
		public int Channel { get; }
		public long CurrentHP { get; set; }
		private int ReducePeriod { get; }
		private long ReduceAmount { get; }
		public SkillSpecification SkillSpecification { get; }
		private ExpirableObjectHolder<DotAbility> DotAbility { get; }
		private MaxHpOverHealEffect OverHealEffect { get; }
		private Character owner { get; }
	}

	public class KnockbackInfo
	{
		private Character owner;
		private IEnumerator knockbackExecuter;
		private float speed;
		private int durationTick;
		public KnockbackEffect KnockbackEffect { get; }
	}

	public class ActionLock
	{
		private LockStatus lockStatus;
		public bool IsLocked { get; }
	}

	public enum ActionProgress
	{
		None = 0,
		Running = 1,
		Finished = 2,
	}

	public enum HeroStatus
	{
		None = 0,
		Dead = 1100,
		Dying = 1110,
		Exiled = 1150,
		Suppressed = 1200,
		Stasis = 1300,
		Knockback = 1410,
		Pulling = 1420,
		Airborn = 1430,
		Stoned = 1500,
		Stunned = 1600,
		Paralysis = 1601,
		Emp = 1602,
		Purify = 1603,
		Groggy = 1604,
		Hit = 1605,
		Frozen = 1606,
		Panic = 1610,
		Charmed = 1710,
		Fear = 1720,
		Polymorph = 1800,
		ForcedIdle = 1900,
		Taunted = 2100,
		ConcentratedTarget = 2110,
		Confusion = 2120,
		MindControlled = 2200,
		Silence = 2300,
		Blind = 2400,
		Entangle = 2500,
		Slow = 2501,
		Immortal = 2700,
		Indestructible = 2701,
		DisableNormalAttack = 2600,
		DisableExSkill = 2601,
		DisablePassiveSkill = 2602,
		DisablePublicSkill = 2603,
		ImmuneDamageAttack = 3150,
		ImmuneDamageAll = 3151,
		ImmuneDamageBySkillType = 3152,
		ImmuneDead = 3210,
		ImmuneStoned = 3220,
		ImmuneKnockback = 3230,
		ImmunePulling = 3240,
		ImmuneAirborn = 3250,
		ImmuneStunned = 3260,
		ImmuneCharmed = 3270,
		ImmuneFear = 3280,
		ImmunePolymorph = 3290,
		ImmuneForcedIdle = 3300,
		ImmuneMindControl = 3310,
		ImmuneSilence = 3320,
		ImmuneBlind = 3330,
		ImmuneParalysis = 3340,
		ImmuneEmp = 3350,
		ImmunePurify = 3360,
		ImmuneGroggy = 3370,
		ImmuneConcentratedTarget = 3371,
		ImmuneConfusion = 3372,
		ImmuneCrowdControl = 3510,
		ImmuneGroggyGaugeAdd = 3520,
		Rage = 4100,
		Untargetable = 4200,
		Metamorph = 4400,
		Thorns = 5000,
		All = 2147483647,
	}

	public class StatChangeEffect : LogicEffect, IEquatable<StatChangeEffect>
	{
		public EndCondition EndCondition { get; }
		public string EndConditionArgumentFirst { get; }
		public string EndConditionArgumentSecond { get; }
		public EndCondition RemoveCondition { get; }
		public string RemoveConditionArgumentFirst { get; }
		public string RemoveConditionArgumentSecond { get; }
		public StatType StatType { get; }
		public long BaseAmount { get; set; }
		public long TargetCoefficientAmount { get; set; }
		public bool Dispellable { get; }
		public StatType CasterStatType { get; }
		public long CasterCoefficientAmount { get; }
		public long CasterStatAmount { get; }
		public int StackSameEffectCount { get; }
		public bool ExpireOldIfStackCountOver { get; }
		public bool IsForceApplied { get; set; }
		public bool Equals(StatChangeEffect other)
		{
			return default;
		}

	}

	public class EquipmentProcessor
	{
		private HashSet<ExpirableObjectHolder<EquipmentOptionChangeEffect>> expirableEffects;
		public IList<Equipment> Equipments { get; }
		public IDictionary<EquipmentOptionType, long> OptionTable { get; }
		private List<Equipment> equipList { get; }
	}

	public class Equipment : IEquatable<Equipment>
	{
		public static Equipment Invalid { get; }
		public bool IsValid { get; }
		public long ServerId { get; }
		public long UniqueId { get; }
		public int Level { get; }
		public long StackCount { get; }
		public int Tier { get; }
		public EquipmentOptionCollection Options { get; }
		public string DamageFactorGroupId { get; }
		public bool Equals(Equipment other)
		{
			return default;
		}

	}

	public enum HeroSummaryDetailFlag
	{
		None = 0,
		BattleProperty = 2,
		BattleStatistics = 4,
		NumericLogs = 8,
		StatSnapshot = 16,
		Default = 14,
		All = 30,
	}

	public class SequentialSkillCardManager : SkillCardManager
	{
		public Character Owner;
		public SkillCard SkillCardToUse { get; }
	}

	public struct StatusParams : IEquatable<StatusParams>
	{
		public static readonly StatusParams Empty;
		public EntityId InvokerId { get; }
		public BattleEntity Invoker { get; }
		public SkillSpecification SkillSpecification { get; }
		public HeroStatus Status { get; }
		public bool IsCrowdControl { get; }
		public int Duration { get; set; }
		public ForceMoveParams ForceMove { get; }
		public string LogicEffectGroupId { get; }
		public string LogicEffectTemplateId { get; }
		public uint LogicEffectVisualIdHash { get; }
		public long ParameterNumber { get; }
		public string Parameter { get; }
		public string ParameterSecond { get; }
		public LogicEffectCategory Category { get; }
		public bool Dispellable { get; }
		public string SkillEntityName { get; }
		public Func<bool> ExpirationCheck { get; }
		public bool IsDurationChangedByStat { get; }
		public bool Equals(StatusParams other)
		{
			return default;
		}

	}

	public interface IRandomService
	{
	}

	public class LifeGainEventArgs : EventArgs
	{
		public EntityId SummonerId { get; set; }
		public EntityId InvokerId { get; set; }
		public EntityId TargetId { get; set; }
		public SkillSpecification SkillSpecification { get; set; }
		public int DotIndex { get; set; }
		public long Amount { get; set; }
		public long RawAmount { get; set; }
		public LifeGainType LifeGainType { get; set; }
		public bool TriggerOtherEffect { get; set; }
		public bool ForceFloaterHide { get; set; }
		public bool IsAccumulatedHeal { get; }
		public Vector2 HitPosition { get; set; }
		public Vector2 BulletPosition { get; }
		public Vector2 BulletDirection { get; }
		public Entity BulletEntity { get; }
		public string TemplateId { get; }
		public int Channel { get; }
	}

	public class LogicEffectHitEventArgs : EventArgs, IEquatable<LogicEffectHitEventArgs>
	{
		public LogicEffect Effect { get; set; }
		public uint TypeOfLogicEffectHash { get; set; }
		public SkillSpecification SkillSpecification { get; }
		public LogicEffectCategory Category { get; }
		public EntityId AttackerId { get; set; }
		public BehaviorType AttackerBehavior { get; set; }
		public ActionState AttackerActionState { get; set; }
		public EntityId TargetId { get; set; }
		public EntityId ObstacleOwnerId { get; set; }
		public string SkillEntityName { get; set; }
		public string LogicEffectGroupId { get; set; }
		public uint CommonVisualIdHash { get; }
		public int DurationFrame { get; set; }
		public Vector2 HitPosition { get; set; }
		public Vector2 BulletPosition { get; set; }
		public Vector2 BulletDirection { get; set; }
		public Entity BulletEntity { get; set; }
		public int DotIndex { get; set; }
		public string TemplateId { get; }
		public bool IsHit { get; }
		public SkillType SkillType { get; }
		public bool Equals(LogicEffectHitEventArgs other)
		{
			return default;
		}

	}

	public class LogicEffectImmuneEventArgs : EventArgs, IEquatable<LogicEffectImmuneEventArgs>
	{
		public EntityId AttackerId { get; set; }
		public EntityId TargetId { get; set; }
		public string TemplateId { get; set; }
		public LogicEffectCategory Category { get; }
		public int DurationFrame { get; }
		public Vector2 HitPosition { get; }
		public Vector2 BulletPosition { get; }
		public Vector2 BulletDirection { get; }
		public Entity BulletEntity { get; }
		public FontType OverrideFontType { get; }
		public bool ForceFloaterHide { get; }
		public bool Equals(LogicEffectImmuneEventArgs other)
		{
			return default;
		}

	}

	public class AttackEventArgs : EventArgs
	{
		private readonly string channel;
		public BattleEntity Attacker { get; set; }
		public BehaviorType AttackerBehavior { get; set; }
		public ActionState AttackerActionState { get; set; }
		public BattleEntity Target { get; set; }
		public BattleEntity TargetOrigin { get; set; }
		public BattleEntity OriginalTargetWhenHitObstacle { get; set; }
		public string SkillEntityName { get; set; }
		public SkillSpecification SkillSpecification { get; set; }
		public Vector2 HitPosition { get; set; }
		public long Damage { get; set; }
		public FontType HitResultType { get; set; }
		public bool ForceFloaterHide { get; set; }
		public LogicEffectCategory Category { get; }
		public AttackLogicEffectType LogicEffectType { get; }
		public Entity BulletEntity { get; }
		public Vector2 BulletPosition { get; }
		public Vector2 BulletDirection { get; }
		public int Channel { get; }
	}

	public class DamageResultEventArgs : EventArgs
	{
		public BattleEntity Attacker { get; set; }
		public EntityId AttackerId { get; set; }
		public EntityId SummonerId { get; }
		public EntityId TargetId { get; set; }
		public EntityId FirstAttackerId { get; set; }
		public LogicEffectCategory LogicEffectCategory { get; set; }
		public SkillSpecification SkillSpecification { get; set; }
		public long AttackPower { get; set; }
		public int Stability { get; set; }
		public long ResultDamage { get; set; }
		public long Damage { get; set; }
		public long AbsorbedDamage { get; set; }
	
		[JsonIgnore]
		public bool IsDamaged { get; }
		public long CriticalMultiplier { get; set; }
	
		[JsonIgnore]
		public bool IsNormalAttack { get; }
		public FontType HitResult { get; }
	
		[JsonIgnore]
		public bool IsCritical { get; }
		public bool TriggerOtherEffect { get; set; }
		public Vector2 HitPosition { get; set; }
		public Vector2 BulletPosition { get; set; }
		public Vector2 BulletDirection { get; set; }
		public Entity BulletEntity { get; set; }
	}

	public class DataLogicEffectComparer : Comparer<LogicEffect>
	{
		public override int Compare(LogicEffect x, LogicEffect y)
		{
			return default;
		}

	}

	public class BattleEventSnapshot
	{
		public int Frame { get; }
		public IList<BattleEntitySpawnedEventArgs> BattleEntitySpawnedSnapshots { get; set; }
		public IList<BattleEntityRemovedEventArgs> BattleEntityRemovedSnapshots { get; set; }
	
		[JsonIgnore]
		public IList<EffectAreaSpawnedEventArgs> EffectAreaSpawnedSnapshots { get; set; }
		public IList<ObstacleEventArgs> ObstacleDestroySnapshots { get; set; }
		public IList<ObstacleEventArgs> ObstacleStateChangeSnapshots { get; set; }
		public IList<BattleItemActivatedEventArgs> BattleItemActivatedSnapshots { get; set; }
		public IList<BattleItemEffectEventArgs> BattleItemEffectedSnapshots { get; set; }
		public IList<BattleItemRecognitionEventArgs> BattleItemRecognizedSnapshots { get; set; }
		public ICollection<LogicEffectHitEventArgs> LogicEffectHitSnapshots { get; set; }
		public ICollection<StatusResistEventArgs> StatusResistSnapshots { get; set; }
		public IList<CharacterFormConvertedEventArgs> CharacterFormConversionSnapshots { get; set; }
		public IList<BeamEventArgs> BeamSpawnedSnapshots { get; set; }
		public IList<AuraEventArgs> AuraSpawnedSnapshots { get; set; }
		public IList<NormalAttackSpawnedEventArgs> NormalAttackSpawnedSnapshots { get; set; }
		public IList<NormalAttackHitEventArgs> NormalAttackHitSnapshots { get; set; }
		public IList<ProjectileSpawnedEventArgs> ProjectileSpawnedSnapshots { get; set; }
		public IList<ProjectileCollidedEventArgs> ProjectileCollidedSnapshots { get; set; }
		public IList<BeamEventArgs> BeamCollidedSnapshots { get; set; }
		public IList<SkillEntityRemovedEventArgs> SkillEntityRemovedSnapshots { get; set; }
		public IList<DotEventArgs> DotAttachedSnapshots { get; set; }
		public IList<DotEventArgs> DotRemovedSnapshots { get; set; }
		public IList<ActionChangedEventArgs> ActionChangeSnapshots { get; set; }
		public IList<ActionChangedEventArgs> ActionInterruptedSnapshots { get; set; }
		public IList<CharacterInteractWithTSSEventArgs> TssInteractionSnapshots { get; set; }
		public IList<AttackEventArgs> AttackResultSnapshots { get; set; }
		public IList<LifeGainEventArgs> LifeGainSnapshots { get; set; }
		public IList<LogicEffectImmuneEventArgs> LogicEffectImmuneSnapshots { get; set; }
		public IList<KillEventArgs> KillSnapshots { get; set; }
		public IList<StatusAddedEventArgs> StatusAddedSnapshots { get; set; }
		public IList<StatusRemovedEventArgs> StatusRemovedSnapshots { get; set; }
		public IList<CharacterGroundNodeChangedEventArgs> GroundNodeChangeSnapshots { get; set; }
		public IList<SkillCardEventArgs> SkillCardSnapshots { get; set; }
		public IList<PassiveTriggeredEventArgs> PassiveTriggeredSnapshots { get; set; }
		public IList<SupportSkillEventArgs> SupportActorChangeSnapshots { get; set; }
		public IList<CharacterPhaseChangedEventArgs> CharacterPhaseChangedSnapshots { get; set; }
		public IList<ParticleEffectEventArgs> ParticleEffectSnapshots { get; set; }
		public IList<CoverStateChangedEventArgs> CoverStateChangedSnapshots { get; set; }
		public DamageUpdatedEventArgs DamageUpdatedSnapshot { get; set; }
		public bool AskContinue { get; set; }
	}

	[Serializable]
	public sealed class TeamSetting : IEquatable<TeamSetting>
	{
		public long AccountId { get; set; }
		public long TeamId { get; set; }
		public string TeamName { get; set; }
	
		[JsonIgnore]
		public GroupTag GroupTag { get; set; }
		public long LeaderCharacterServerId { get; set; }
		public bool CheckTSSInteractionServerId { get; set; }
		public long TSSInteractionCharacterServerId { get; set; }
		public long TSSInteractionCharacterUniqueId { get; set; }
	
		[JsonIgnore]
		public FormationLocationKey FormationLocationKey { get; set; }
		public int EchelonNumber { get; set; }
		public bool IsExtension { get; set; }
		public IList<HeroSetting> Starters { get; set; }
		public IList<HeroSetting> Supporters { get; set; }
		public IList<GroundPassiveSetting> GroundPassives { get; set; }
		public IList<IDefaultStatChangeInfo> DefaultStatChangeInfos { get; set; }
		public ArenaSetting ArenaSetting { get; set; }
		public SkillCardHand SkillCardHand { get; set; }
		public List<long> SkillCardMulliganCharacterIds { get; set; }
		public List<string> HexaBuffs { get; set; }
	
		[JsonIgnore]
		public StatCorrection StatCorrection { get; set; }
	
		[JsonIgnore]
		public int TotalCharacterCount { get; }
	
		[JsonIgnore]
		public int HandCount { get; set; }
		public bool Equals(TeamSetting other)
		{
			return default;
		}

	}

	public sealed class RaidSetting
	{
		public bool IsPractice { get; set; }
		public long RaidServerId { get; set; }
		public long RaidSeasonId { get; set; }
		public long RaidGroupId { get; set; }
		public string SecretCode { get; set; }
		public int RaidBossIndex { get; set; }
	
		[JsonIgnore]
		public int LastBossIndex { get; }
		public long RaidBossHP { get; set; }
		public int RaidBossInitialPhase { get; set; }
		public long GroggyPoint { get; set; }
		public List<long> SubPartsHPs { get; set; }
		public bool IsTicket { get; set; }
		public RaidMemberCollection RaidMembers { get; set; }
	}

	public sealed class EventBattleSetting
	{
		public List<long> BuffIds { get; set; }
	}

	public sealed class TimeAttackSetting
	{
		public bool IsPractice { get; set; }
		public long TimeAttackServerId { get; set; }
		public long TimeAttackSeasonId { get; set; }
		public string SecretCode { get; set; }
		public long GeasId { get; set; }
		public long DungeonId { get; set; }
	}

	public class SightChangedEventArgs : EventArgs
	{
		public GroupTag groupTag { get; set; }
	}

	public class BlockedArea
	{
		private bool[] goThroughDirectionBlocked;
		public int startX;
		public int startY;
		public int endX;
		public int endY;
		private BlockedAreaBattleItem owner;
		private bool[][] gridNonBlocked;
		public Circle Circle { get; set; }
		public bool Item { get; }
	}

	public class GroundFormationBeacon
	{
		private int ignoreAStarIndexInPathList;
		private bool isNeedToUpdatePathList;
		private readonly Character ownerCharacter;
		private bool checkTSSBlocked;
		private GroundNodeType passableNodeType;
		private readonly CharacterGroup ownerCharacterGroup;
		private readonly Battle battle;
		private LastFailedPathInfo lastFailedPathInfo;
		private GroundNode lastTargetStartNode;
		private List<GroundNode> lastMoveList;
		public FormationLine Line { get; set; }
		public int LineIndex { get; set; }
		public List<GroundNode> PathList { get; set; }
		public Character MaxPositionCharacter { get; set; }
		public float MaxPositionRatioInGroup { get; set; }
		public float MinPositionRatioInGroup { get; set; }
		public float MyPositionRatioInGroup { get; set; }
	}

	[Serializable]
	public struct StatCorrection : IEquatable<StatCorrection>
	{
		public static readonly StatCorrection Empty;
		public static readonly StatCorrection Default;
		public long SightRangeBase;
		public BasisPoint SightRangeRate;
		public long WeaponRangeBase;
		public BasisPoint WeaponRangeRate;
		public long SkillRangeBase;
		public BasisPoint SkillRangeRate;
		public bool SightRangeMax;
	
		[JsonIgnore]
		public bool IsEmpty { get; }
		public bool Equals(StatCorrection other)
		{
			return default;
		}

	}

	public abstract class SkillCardManager
	{
		public List<SkillCard> Deck { get; set; }
		protected Battle Battle { get; set; }
		public GroupTag GroupTag { get; set; }
		protected CharacterGroup CharacterGroup { get; set; }
		protected List<ValueTuple<BattleEntity, TacticEntityType>> CharactersInfo { get; set; }
	}

	public class SkillActor : BattleEntity, IHeroSummarizable
	{
		private EventHandler<ActionChangedEventArgs> ActionChanged;
		private EventHandler<ActionChangedEventArgs> ActionInterrupted;
		private EventHandler<SupportSkillEventArgs> StateChanged;
		public EventHandler<SkillActionRegisteredEventArgs> SkillActionRegistered;
		protected bool skillActivated;
		private Dictionary<SkillSlot, int> ExtraSkillCostTable;
		public virtual Battle BattleCache { get; set; }
		public override GroupTag GroupTag { get; }
		public override HeroAction CurrentAction { get; set; }
		public SkillProcessor SkillProcessor { get; }
		public ActionLock ActionLock { get; }
		protected IDictionary<BehaviorType, NewSkillAction> ActionTable { get; }
		public override Vector2 Position2D { get; }
		public override Vector2 Direction { get; set; }
		public Dictionary<ValueTuple<BulletType, ArmorType>, ValueTuple<long, DamageAttribute, long, long, bool>> BulletArmorFactorTable { get; set; }
		public Dictionary<BulletType, List<ValueTuple<long, long, int, SkillSlot>>> BulletArmorDamageFactorOverrideTable { get; set; }
		public Dictionary<SkillSlot, List<ValueTuple<BulletType, int>>> BulletTypeOverrideTable { get; set; }
		public virtual HeroSummaryDetailFlag SummaryDetail { get; }
		public override BehaviorType CurrentBehavior { get; set; }
		public override ActionState CurrentActionState { get; }
		public override bool Alive { get; }
		public override bool HasCrowdControl { get; }
	}

	[Serializable]
	public class TemporaryCanUseSkillArea
	{
		public bool IsHideVisual;
		public string CommandId;
		public long Radius;
		public GroupTag GroupTag;
		public Vector3 Position;
		public float RadiusSqr { get; set; }
		public Vector2 Position2D { get; set; }
	}

	public class SyncUseSkillManager
	{
		private List<SyncUseSkillGroup> syncUseSkillGroupList;
	}

	public class GroundGrid
	{
		private const float DistanceToNoTSS = 2;
		private static readonly float ROOT2;
		public static readonly int MaxCost;
		public static readonly GroundNode[] Directions;
		public string Version;
		public float Gap;
		public float OnePerGap;
		public int X;
		public int Y;
		public float StartX;
		public float StartY;
		private List<HashSet<sbyte>> connectedLayerMapping;
		private List<HashSet<sbyte>> temporaryConnectedLayerMapping;
		private Dictionary<GroundNode, GroundNodeType> temporaryToChangeLayerTable;
		private List<Shape> movingAreaShapeList;
		public float halfGap { get; }
		public GroundNode[] GroundNodes { get; set; }
		public GroundNode Item { get; set; }
		public bool PathFindFailOverOn { get; set; }
	}

	public class GroundStage
	{
		public string GridVersion;
		public GroundGlobal Global;
		public List<GroundSection> Sections;
		public List<GroundFormation> Formations;
		public List<GroundFormation> EnemyFormations;
		public List<TemporaryCanUseSkillArea> TemporaryCanUseSkillAreas;
		public int CurSectionID;
		public Battle battle;
		public GroundSection CurMapSection { get; }
	}

	public abstract class BattleCommand : IEquatable<BattleCommand>
	{
		public GroupTag ExecuterTag { get; }
		public int IssuedFrame { get; set; }
		public int ExecuteFrame { get; set; }
		public bool Equals(BattleCommand other)
		{
			return default;
		}

	}

	public class StatSnapshotCollection : KeyedCollection<StatType, StatSnapshot>
	{
		protected override StatType GetKeyForItem(StatSnapshot item)
		{
			return default;
		}

	}

	public class BattleNumericLog : IEquatable<BattleNumericLog>
	{
		public BattleEntityType EntityType { get; set; }
		public BattleLogCategory Category { get; set; }
		public BattleLogSourceType Source { get; set; }
		public long CalculatedSum { get; set; }
		public long AppliedSum { get; set; }
		public long Count { get; set; }
		public long CriticalMultiplierMax { get; set; }
		public long CriticalCount { get; set; }
		public long CalculatedMin { get; set; }
		public long CalculatedMax { get; set; }
		public long AppliedMin { get; set; }
		public long AppliedMax { get; set; }
		public bool Equals(BattleNumericLog other)
		{
			return default;
		}

	}

	public struct EquipmentSetting : IEquatable<EquipmentSetting>
	{
		public const int InvalidId = -1;
	
		[JsonIgnore]
		public bool IsValid { get; }
		public long ServerId { get; set; }
		public long UniqueId { get; set; }
		public int Level { get; set; }
		public int Tier { get; set; }
		public bool Equals(EquipmentSetting other)
		{
			return default;
		}

	}

	public class KillLogCollection : Collection<KillLog>
	{
	}

	public class CostRegenSnapshotCollection : KeyedCollection<long, SkillCostRegenSnapshot>
	{
		[JsonIgnore]
		private SkillCostRegenSnapshot _lastSnapshot;
		protected override long GetKeyForItem(SkillCostRegenSnapshot item)
		{
			return default;
		}

	}

	public struct SkillCostAddSnapshot
	{
		public long Frame { get; set; }
		public float Added { get; set; }
	}

	public struct SkillCostUseSnapshot
	{
		public long Frame { get; set; }
		public float Used { get; set; }
		public long CharId { get; set; }
		public int Level { get; set; }
	}

	[Serializable]
	public class TBGHexaTileData
	{
		public string ResourcePath { get; set; }
		public TBGTileType TileType { get; set; }
		public HexLocation Location { get; set; }
	}

	[Serializable]
	public class TBGHexaSpawnData
	{
		public TBGHexaObjectSpawnRule SpawnRule { get; set; }
		public HexLocation Location { get; set; }
		public List<long> UniqueIds { get; set; }
		public List<TBGObjectType> ObjectTypes { get; set; }
		public long ShuffleGroupId { get; set; }
	}

	public interface ITBGObjectInfo
	{
		public abstract long UniqueId { get; }
		public abstract TBGObjectType ObjectType { get; }
		public abstract ParcelInfo Cost { get; }
		public abstract bool Disposable { get; }
		public abstract bool ReEncounterCost { get; }
		public abstract string Key { get; }
		public abstract string PrefabName { get; }
	}

	public enum TBGObjectInteractionType
	{
		None = 0,
		Encounter = 1,
		Portal = 2,
	}

	public class BattleEntityDamagedEventArgs : EventArgs
	{
		public EntityId AttackerId { get; }
		public EntityId TargetId { get; }
		public long DamageTaken { get; }
		public long DamageAbsorbed { get; }
		public FontType HitResultType { get; }
	}

	public class PassiveTriggeredEventArgs : EventArgs
	{
		public SkillSpecification SkillSpecification { get; }
		public SkillSlot Slot { get; }
		public EntityId OwnerId { get; }
		public EntityId TriggerSourceId { get; }
		public PassiveTriggerEvent TriggerEvent { get; }
	}

	public class DamageTransferEffectInfo
	{
		private Battle battle;
		private IEnumerator conditionChecker;
		private string TransferredDamageEffectGroupId;
		private int TransferredDamageEffectLevel;
		public int Channel { get; }
		private ExpirableObjectHolder<DotAbility> DotAbility { get; }
		private DamageTransferEffect DamageTransferEffect { get; }
		private BattleEntity owner { get; }
	}

	public class HealConvertDamageEffectInfo
	{
		private Battle battle;
		private IEnumerator conditionChecker;
		private string TransferredHealDamageGroupID;
		public int Channel { get; }
		private ExpirableObjectHolder<DotAbility> DotAbility { get; }
		private HealConvertDamageEffect HealConvertDamageEffect { get; }
		private BattleEntity owner { get; }
	}

	public class EntityTargetContainer
	{
		private BattleEntity owner;
		private SkillSlot skillSlot;
		private Vector2 targetPosition;
		private Vector2 targetDirection;
		private readonly List<BattleEntity> targets;
		private TargetCandidateRule targetCandidateRule;
		public BehaviorType BehaviorType { get; set; }
		public Vector2 TargetPosition { get; }
		public Vector2 TargetDirection { get; }
		public BattleEntity MainTarget { get; }
		public bool HasTarget { get; }
		public bool HasMainTarget { get; }
		public IList<BattleEntity> Targets { get; }
		public TargetingType TargetingType { get; set; }
	}

	public class EntityTargetFinder
	{
		private HashSet<BattleEntity> DuplicationCheckSet;
		private BattleEntity Owner { get; }
		private GroupTag OwnerTag { get; }
		public bool CanNotTargetObstacle { get; set; }
	}

	[Serializable]
	public class GroundNode : IEquatable<GroundNode>
	{
		public int X;
		public int Y;
		public GroundNodeType OriginalNodeType;
		public GroundNodeType NodeType;
		public Vector2 Position2D;
		public float PositionHeight;
		public bool CanNotUseSkill;
		public sbyte Layer;
		[JsonIgnore]
		public sbyte OriginalLayer;
		[JsonIgnore]
		public float temporaryHeight;
		[JsonIgnore]
		private readonly int hash;
		[JsonIgnore]
		public bool TSSBlocked;
	
		[JsonIgnore]
		public float PositionHeightWithTemporaryChange { get; }
	
		[JsonIgnore]
		public Vector3 PositionVisual { get; }
	
		[JsonIgnore]
		public HashSet<GroundObstacle> CanNotStandByNearObstacles { get; set; }
		public HashSet<GroundObstacle> CanStandByNearObstacles { get; set; }
		public bool Equals(GroundNode other)
		{
			return default;
		}

	}

	public class BattleEntityStat : ICloneable
	{
		private Dictionary<StatType, ValueTuple<long, long, long, long>> minMaxValueTable;
		private Dictionary<StatType, long> valueTable;
		public static BattleEntityStat Empty { get; }
		public CharacterLevelStatFactorExcel LevelFactor { get; set; }
		public long Item { get; }
		public IEnumerable<StatType> StatTypes { get; }
		public int Level { get; set; }
		public int Grade { get; set; }
		public object Clone()
		{
			return default;
		}

	}

	public class StackDamageProcessor
	{
		private List<StackDamageInfo> stackDamageInfoList;
	}

	public class AccumulateEffectProcessor
	{
		private List<AccumulateEffectInfo> accumulateInfoList;
	}

	public class GaugeEffectProcessor
	{
		private List<GaugeEffectInfo> GaugeInfoList;
	}

	public class ImmuneProcessor
	{
		private BattleEntity owner;
		private List<ExpirableObjectHolder<ImmuneEffect>> runningImmuneList { get; }
		public IEnumerable<ExpirableObjectHolder<ImmuneEffect>> RuntimeImmunes { get; }
		private List<ImmuneEffect> addedImmunes { get; set; }
		private List<ImmuneEffect> expiredList { get; set; }
		private List<ImmuneEffect> markRemoveList { get; set; }
	}

	public abstract class ImmuneEffect : LogicEffect
	{
		public long DurationFrame;
		public bool Dispellable { get; }
		public abstract FontType FloaterType { get; }
	}

	public class DotProcessor
	{
		public List<ExpirableObjectHolder<DotAbility>> ExpirableAbilities { get; }
		private List<EffectArea> attachedEffectAreas { get; }
		private List<IAmplifyDoTEffect> attachedAmplifyDoTEffects { get; }
	}

	public abstract class LogicEffectValue
	{
		public int Level { get; }
		public string LogicEffectGroupId { get; }
		public string LogicEffectTemplateId { get; }
		public LogicEffectCategory Category { get; }
		public int Channel { get; }
		public BasisPoint ApplyRate { get; }
		public uint CommonVisualIdHash { get; }
		public bool ForceFloaterHide { get; set; }
		public int PriorityWhenSameFrame { get; }
	
		[JsonIgnore]
		public bool IsDisabled { get; }
	}

	public class SkillDataPack
	{
		public NewSkillAction Action { get; }
		public AutoUseCheck AutoUseCheck { get; }
		public bool CheckCanUseSkillPoint { get; }
		public SkillExcel Excel { get; }
		public int Level { get; }
	}

	public enum SkillCardState
	{
		None = 0,
		InHand = 1,
		InDeck = 2,
		Used = 3,
		Cast = 4,
		InputReceived = 5,
		CoolTime = 6,
		CoolTimeComplete = 7,
		Disabled = 8,
		Waiting = 9,
		Switched = 10,
	}

	public enum ShapeType
	{
		None = 0,
		Circle = 3,
		Donut = 4,
		Fan = 5,
		LineSegment = 6,
		OBB = 7,
	}

	public class ManualSkill
	{
		public SkillSpecification SkillSpecification { get; }
		public ManualSkillTypes ManualSkillType { get; }
		public IList<SkillAbilityValue> Abilities { get; }
	}

	public class EventSkill
	{
		public ManualSkill Skill { get; }
		public IList<SkillAbilityValue> Abilities { get; }
		public TargetCandidateRule CandidateRule { get; }
		public TargetSortRule SortRule { get; }
		private TargetFindRule TargetRule { get; }
	}

	public abstract class CostSkillCardManager : SkillCardManager
	{
		protected virtual bool CanRegenCost { get; }
		public virtual bool IsRegenBan { get; }
		public abstract SkillPriorityCheckTarget FeverTarget { get; }
		public float MaxCost { get; set; }
		public float CurCost { get; set; }
		public virtual float CurrentFrameUsableCost { get; }
		public float FeverChargeScale { get; set; }
		public float CostPerFrame { get; set; }
		public bool IsShuffle { get; set; }
		public bool IsFeverTime { get; }
		public ValueTuple<bool, float, float, float> FeverInfo { get; set; }
		public long RegenStartDelayFrame { get; set; }
		public bool IsMainPlayerSkillCard { get; set; }
		protected float RegenCostBefore { get; set; }
	}

	public class SkillCardEventArgs : EventArgs
	{
		public GroupTag GroupTag { get; }
		public int Index { get; }
		public SkillCard SkillCard { get; }
		public SkillCardState State { get; }
	}

	public class HandSlot
	{
		public SkillCard SkillCard;
		public long SlotCoolFrame;
	}

	public interface ICancelableBySkill
	{
	}

	public abstract class SkillAbilityValue
	{
		public int StartDelay { get; }
		public IList<LogicEffectValue> LogicEffectValues { get; }
		public IList<AbilityModifier> Modifiers { get; }
	}

	public enum AreaTransformTypes
	{
		None = 0,
		RadiusIncrement = 1,
		RadiusDecrement = 2,
		ObbCenterIncrement = 3,
		ObbCenterDecrement = 4,
		FanClockWise = 5,
		FanCounterClockWise = 6,
		FanClockwiseRound = 7,
		FanCounterClockwiseRound = 8,
	}

	public class DirectionRotator
	{
		public Vector2 Right { get; }
		public Vector2 Forward { get; }
		public float CurrentAngle { get; set; }
		private float DestAngle { get; set; }
	}

	public abstract class SummonEntityValue : SkillEntityValue
	{
		public AreaSpawnerValue InitialAreaSpawnerEntity;
		public SkillEntitySpawnerValue InitialEntitySpawner;
		public string SpawnTemplateId { get; }
		public float AngleOffset { get; }
		public int Duration { get; }
		public bool DestroyAlreadyExist { get; }
		public bool SummonAsEnemy { get; }
		public bool SpawnSameGridLayerAsInvoker { get; set; }
		public MovingAreaOptions MovingAreaOption { get; }
	}

	public class AreaSpawnerValue : SkillEntityValue
	{
		public int Duration { get; }
		public List<ValueTuple<int, Hash64, AreaEntityValue>> EntityTimeline { get; }
	}

	public class SkillEntitySpawnerValue : SkillEntityValue, ICancelableBySkill
	{
		public int SkillLevel { get; }
		public int Duration { get; }
		public EntitySpawnRule SpawnRule { get; }
		public bool RemoveEntityIfSkillCancel { get; }
		public bool OverrideSkillStartTimingWithSpawnerSpawn { get; }
		public bool FireToNextTargetWhenEachToEach { get; }
		public SkillToTargetDistributeType DistributeType { get; }
		public List<ValueTuple<int, SpawnCondition, SkillEntityValue>> EntityTimeline { get; }
		public bool IsRemoveEntityIfSkillCancel()
		{
			return default;
		}

	}

	public enum SpawnPositionTypes
	{
		None = 0,
		Invoker = 1,
		InputPosition = 2,
		InputBattleEntity = 3,
		AliveAllyCenter = 4,
		AliveEnemyCenter = 5,
		GroundCenter = 6,
		BattleEntity = 7,
		WorldPosition = 8,
		SkillCommandSelectedTarget = 9,
		SkillCommandSelectedPosition = 10,
	}

	public enum SpawnDirectionTypes
	{
		None = 0,
		Invoker = 1,
		Input = 2,
		ToTarget = 3,
		AllyToEnemy = 4,
		EnemyToAlly = 5,
		AliveAllyCenter = 6,
		AliveEnemyCenter = 7,
		WorldPosition = 8,
		CasterToTarget = 9,
		TargetToCaster = 10,
	}

	public enum ProjectileTypes
	{
		None = 0,
		TargetCharacter = 1,
		TargetPosition = 2,
		Nontarget = 3,
		Max = 4,
	}

	public enum TargetingType
	{
		None = 0,
		Target = 1,
		Position = 2,
	}

	public enum TargetEntityType
	{
		None = 0,
		Character = 5,
		Character_Except_TSS = 1,
		TSS = 4,
		Supporter = 8,
		Obstacle = 2,
	}

	public enum TargetSideId
	{
		None = 0,
		Self = 2,
		Ally_Except_Self = 4,
		Enemy = 8,
		Neutral = 16,
		Ally = 6,
		Self_or_Enemy = 10,
		Self_or_Neutral = 18,
		Ally_or_Enemy = 14,
		Ally_or_Neutral = 22,
		Enemy_or_Neutral = 24,
		All_Except_Self = 12,
		ALL = 2147483647,
	}

	public enum AliveState
	{
		None = 0,
		Alive = 1,
		Dying = 2,
		Dead = 4,
		AliveOrDying = 3,
		AliveOrDead = 5,
		DeadOrDying = 6,
		All = -1,
	}

	[Serializable]
	public struct SchoolConstraint : IEquatable<SchoolConstraint>, IMemoryPackable<SchoolConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly SchoolConstraint Empty;
		public School School;
		public IncludeType IncludeType;
		public bool Equals(SchoolConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct WeaponConstraint : IEquatable<WeaponConstraint>, IMemoryPackable<WeaponConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly WeaponConstraint Empty;
		public WeaponType Weapon;
		public IncludeType IncludeType;
		public bool Equals(WeaponConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct SquadTypeConstraint : IEquatable<SquadTypeConstraint>, IMemoryPackable<SquadTypeConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly SquadTypeConstraint Empty;
		public SquadType SquadType;
		public IncludeType IncludeType;
		public bool Equals(SquadTypeConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct AdaptationConstraint : IEquatable<AdaptationConstraint>, IMemoryPackable<AdaptationConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly AdaptationConstraint Empty;
		public StatType AdaptationType;
		public TerrainAdaptationStat[] AdaptationValues;
		public IncludeType IncludeType;
		public bool Equals(AdaptationConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct BulletConstraint : IEquatable<BulletConstraint>, IMemoryPackable<BulletConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly BulletConstraint Empty;
		public BulletType BulletType;
		public IncludeType IncludeType;
		public bool Equals(BulletConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct TacticRangeConstraint : IEquatable<TacticRangeConstraint>, IMemoryPackable<TacticRangeConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly TacticRangeConstraint Empty;
		public TacticRange[] TacticRanges;
		public IncludeType IncludeType;
		public bool Equals(TacticRangeConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct TagConstraint : IEquatable<TagConstraint>, IMemoryPackable<TagConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly TagConstraint Empty;
		[JsonIgnore]
		private List<Tag> tagNameList;
		public IncludeType IncludeType;
		public List<int> TagNamesInt;
	
		[JsonIgnore]
		public List<Tag> TagNameList { get; set; }
		public bool Equals(TagConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct HPRateConstraint : IEquatable<HPRateConstraint>, IMemoryPackable<HPRateConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly HPRateConstraint Empty;
		public HPRateConstraintType ConstraintType;
		public int HPRate;
		public bool Equals(HPRateConstraint other)
		{
			return default;
		}

	}

	[Serializable]
	public struct TacticRoleConstraint : IEquatable<TacticRoleConstraint>, IMemoryPackable<TacticRoleConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly TacticRoleConstraint Empty;
		public TacticRole[] TacticRole;
		public IncludeType IncludeType;
		public bool Equals(TacticRoleConstraint other)
		{
			return default;
		}

	}

	public enum TargetSortCriteria
	{
		None = 0,
		CurrentHP = 1,
		MaxHP = 2,
		HPRate = 3,
		Distance = 4,
		AttackPower = 5,
		DefensePower = 6,
		BuffCount = 7,
		DebuffCount = 8,
		CrowdControlCount = 9,
		LogicEffectTemplateCount = 10,
		Stat = 11,
		SummonedTime = 12,
		All = 13,
	}

	public enum TargetSortOrder
	{
		None = 0,
		Highest = 1,
		Lowest = 2,
		Random = 3,
	}

	public enum TransformDecideTiming
	{
		SkillStart = 0,
		EntitySpawn = 1,
	}

	public class BeamAbilityFrameValue
	{
		public BeamPhase Phase;
		public int Frame;
		public List<SkillAbilityValue> Abilities;
	}

	public class BeamSplashValue
	{
		public BeamPhase Phase;
		public AreaSpawnerValue AreaSpawner;
		public SkillEntitySpawnerValue SkillEntitySpawner;
		public TargetProjectileEntityValue TargetAttachedEntity;
	}

	public class ChainBeamValue
	{
		public BeamPhase Phase;
		public int CheckTargetRadiusToSpawn;
		public bool AllowParentTargetDupilication;
		public int MaxBranchCount;
		public BeamEntityValue BeamEntityValue;
	}

	public enum SameAuraCheckCondition
	{
		None = 0,
		SameInvokerEntityId = 1,
		SameInvokerTeam = 2,
		SameSkillId = 4,
		SameSkillEntityName = 8,
		All = 15,
	}

	public class TargetSkillEntityValue : SkillEntityValue
	{
		public IList<SkillAbilityValue> Abilities { get; }
	}

	public class StatusComparer : Comparer<ExpirableObjectHolder<StatusResult>>
	{
		public override int Compare(ExpirableObjectHolder<StatusResult> x, ExpirableObjectHolder<StatusResult> y)
		{
			return default;
		}

	}

	public abstract class StatusExecution
	{
		protected Character Owner { get; }
		public EntityId InvokerId { get; set; }
		public int Duration { get; set; }
	}

	public struct ForceMoveParams : IEquatable<ForceMoveParams>
	{
		public static ForceMoveParams Empty;
		public Vector2 Direction { get; }
		public float Distance { get; }
		public TransitionType Transition { get; }
		public bool Equals(ForceMoveParams other)
		{
			return default;
		}

	}

	public class ImmediateKillEffectValue : LogicEffectValue
	{
		public bool IgnoreImmortal { get; }
		public bool IgnoreAppliedCheat { get; }
	}

	public class ModifySkillEffect : LogicEffect
	{
		public IList<SkillSlot> ApplySlots { get; }
		public SkillProperty TargetProperty { get; }
		public StatEvalType EvalType { get; }
		public double Amount { get; }
		public int DurationFrame { get; }
		public bool Dispellable { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	public interface AutoUseCheck
	{
		internal CharacterSkillListKey ActivateCondition { set; }
		public abstract int MaxTriggerCount { get; }
		public abstract int CurrentTriggerCount { get; }
	}

	public class PassiveSkill : IEquatable<PassiveSkill>
	{
		private bool isTriggered;
		public SkillSpecification SkillSpecification { get; }
		public BattleEntity Owner { get; }
		public int MaxExecutionCount { get; }
		public int StartCooltime { get; }
		public int ReuseCooltime { get; }
		public int Duration { get; }
		public PassiveTriggerEvent TriggerEvent { get; }
		public string TriggerExpressionText { get; }
		public string TriggerParametersText { get; }
		public BasisPoint TriggerRate { get; }
		public EchelonConstraint EchelonConstraint { get; }
		public int MaxTriggerCount { get; }
		public int TryCount { get; }
		public long CoolTimeNotTrigger { get; }
		public bool ResetTryCountUseSkill { get; }
		public int CurrentTriggerCount { get; set; }
		public int CurrentTryCount { get; set; }
		public int CurrentCooltime { get; set; }
		public int LastTriggerFrame { get; set; }
		public int Elapsed { get; set; }
		public TargetSideId TargetSide { get; }
		private TargetSortRule TriggerSourceSortRule { get; }
		private TargetCandidateRule TriggerSourceCandidateRule { get; }
		public long RemainedCoolTimeNotTriggerFrame { get; set; }
		public int TimelineDuration { get; }
		public PassiveSkillTargetType SkillTargetType { get; }
		public List<ValueTuple<int, SkillEntityValue>> EntityTimeline { get; }
		public bool Equals(PassiveSkill other)
		{
			return default;
		}

	}

	public abstract class PassiveExecution
	{
		private bool isEvaluationEnabled;
		public SkillSpecification SkillSpecification { get; }
		public PassiveTriggerEvent TriggerEvent { get; }
		public BattleEntity Invoker { get; }
		public BattleEntity TriggerSource { get; }
		protected bool IsActivated { get; set; }
		protected BattleExpression TriggerExpression { get; set; }
		private int MaxTriggerCount { get; }
		private int TryCount { get; }
		protected bool ResetTryCountUseSkill { get; }
		public int Elapsed { get; }
		protected bool CanTrigger { get; }
		public long RemainedCoolTimeNotTriggerFrame { get; }
		private PassiveSkill skillCache { get; }
		private BasisPoint TriggerRate { get; }
		private EchelonConstraint EchelonConstraint { get; }
		private int Duration { get; }
		protected string TriggerExpressionText { get; }
		protected Battle battleCache { get; set; }
	}

	public class RootSelector : PartialSelector
	{
		private Func<int> SwitchBehavior { get; }
		private int BranchIndex { get; set; }
	}

	public enum BehaviorResult
	{
		Failure = 0,
		Success = 1,
		Running = 2,
	}

	[Serializable]
	public class SpawnMovePoint : GroundPoint
	{
		public bool NeedFindPath;
	}

	public class ObstaclePosition
	{
		public ObstaclePoint ObstaclePoint;
		public GroundObstacle GroundObstacle;
	}

	public class LastFailedPathInfo
	{
		public GroundNode StartNode;
		public GroundNode EndNode;
		public List<BlockedArea> BlockedAreas;
		public List<GroundObstacle> GroundObstacles;
	}

	public class LogicEffectExpireChecker
	{
		public int CurrentConditionArgument;
		private IEnumerator ConditionChecker;
		private ExpirableObjectHolder<DotAbility> dotEffect;
		private Action OnStop;
		public LogicEffectEndCondition EndCondition { get; }
		public int EndConditionArgument { get; }
		protected Character Owner { get; }
	}

	public class ShieldEffect : LogicEffect
	{
		public long BaseAmount { get; }
		public StatType TargetStatType { get; }
		public BasisPoint TargetCoefficientAmount { get; }
		public StatType CasterStatType { get; }
		public BasisPoint CasterCoefficientAmount { get; }
		public int DurationFrame { get; }
		public bool IsDispellable { get; }
	}

	public class MaxHpOverHealEffect : HealEffect
	{
		public int TemporaryHpDuration { get; }
		public bool TemporaryHpDispellable { get; }
		public long TemporaryHpLimitRateByTargetMaxHp { get; }
		public int TemporaryHpBaseAmount { get; }
		public long TemporaryHpByOverHealRate { get; }
		public int TemporaryHpReducePeriod { get; }
		public int TemporaryHpReduceBaseAmount { get; }
		public long TemporaryHpReduceByHealAmountRate { get; }
	}

	public class KnockbackEffect : LogicEffect
	{
		public long MoveDuration;
		public long MoveDistance;
		public KnockbackDirection KnockbackDirection;
		public override bool IsDurationChangedByStat { get; }
	}

	public enum LockStatus
	{
		Locked = 0,
		Unlocked = 1,
	}

	public class EquipmentOptionChangeEffect : LogicEffect
	{
		public EquipmentOptionType StatType { get; }
		public StatEvalType EvalType { get; }
		public long Amount { get; }
		public int DurationFrame { get; }
		public bool Dispellable { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	public class EquipmentOptionCollection : Collection<EquipmentOption>
	{
		public IEnumerable<EquipmentOptionType> AllTypes { get; }
	}

	public enum LifeGainType
	{
		None = 0,
		Heal = 1,
		Recover = 2,
	}

	public enum AttackLogicEffectType
	{
		Damage = 0,
		DeadlyAttack = 1,
		TransferredDamage = 2,
		DamageOverTime = 3,
		ChangeDamageOverTime = 4,
		DamageByHit = 5,
		ExtraStatDamage = 6,
		AccumulateDamage = 7,
		MaxHPCapGauge = 8,
	}

	public class SupportSkillEventArgs : EventArgs
	{
		public EntityId EntityId { get; }
		public SkillCardState State { get; }
		public Vector2 TargetPosition { get; }
		public long CharacterId { get; }
	}

	public class DamageUpdatedEventArgs : EventArgs
	{
		public int RaidBossIndex { get; }
		public RaidMemberCollection RaidMembers { get; }
	}

	[Serializable]
	public struct FormationLocationKey
	{
		public long GroupId;
	}

	[Serializable]
	public sealed class HeroSetting : IEquatable<HeroSetting>
	{
		public EntityId EntityId { get; set; }
		public long ServerId { get; set; }
		public long OwnerAccountId { get; set; }
		public AssistRelation AssistRelation { get; set; }
		public long HeroId { get; set; }
		public long CostumeId { get; }
		public int Grade { get; set; }
		public Dictionary<long, long> FavorRankInfo { get; set; }
		public int FavorRank { get; set; }
		public Dictionary<StatType, int> PotentialStatLevelDict { get; set; }
		public int Level { get; set; }
		public long AIId { get; set; }
		public FormationLine Line { get; set; }
		public int LineIndex { get; set; }
		public BasisPoint InitialHPRate { get; set; }
		public IList<HeroStatus> PermanentStatus { get; set; }
		public IDictionary<SkillSlot, int> SkillLevelTable { get; set; }
		public IList<EquipmentSetting> EquipmentSettings { get; set; }
		public bool IsCharacterWeaponEquipped { get; }
		public WeaponSetting WeaponSetting { get; set; }
		public GearSetting GearSetting { get; set; }
		public CostumeSetting CostumeSetting { get; set; }
		public bool Equals(HeroSetting other)
		{
			return default;
		}

	}

	[Serializable]
	public class GroundPassiveSetting
	{
		public string SkillGroupId { get; set; }
		public int SkillLevel { get; set; }
	}

	public interface IDefaultStatChangeInfo
	{
	}

	[Serializable]
	public class ArenaSetting
	{
		public long TeamLevel { get; set; }
		public long RepresentCharacterId { get; set; }
		public long RepresentCharacterCostumeId { get; set; }
		public long ArenaMapUniqueId { get; set; }
		public long EmblemId { get; set; }
	}

	public class BlockedAreaBattleItem : BattleItem
	{
		private BlockedArea blockedArea;
	}

	public abstract class NewSkillAction : HeroAction
	{
		public Vector2 RootMotionStartPosition;
		public Vector2 RootMotionEndPosition;
		private bool ignoreCrashByTSSObstacleCheck;
		public SkillSpecification SkillSpecification { get; }
		public TargetingType PrimaryTargetingType { get; }
		public TargetCandidateRule PrimaryCandidateRule { get; }
		public TargetSortRule PrimarySortRule { get; }
		public SkillApplyType PrimarySkillApplyType { get; set; }
		protected RootMotionFrame RootMotionFrame { get; }
		public long Range { get; set; }
		public long Angle { get; set; }
		public long MinRange { get; set; }
		protected SpawnDirectionTypes ExecuterDirectionType { get; }
		public Vector2 ExecuterDirectionWorldPosition { get; }
		public SpawnDirectionTypes CurrentInvokerDirectionType { get; set; }
		public Vector2 CurrentInvokerDirectionWorldPosition { get; set; }
		public SkillEntityDAO MainEntityData { get; }
		public LevelRootMotionMoveValue RootMotionMove { get; }
		public bool IsAttackEnterSkipByLastSkill { get; }
	}

	public class SyncUseSkillGroup
	{
		private IEnumerator coTryToSkillUse;
		public int SyncSkillUseGroupId { get; }
		private int CoolDown { get; }
		public int CoolDownCurrent { get; set; }
		public List<ValueTuple<Character, SkillSlot>> CharacterList { get; set; }
		public List<ValueTuple<SupportActor, SkillSlot>> SupporterList { get; set; }
	}

	[Serializable]
	public class GroundGlobal
	{
		public Vector3 Position;
		public List<GroundEvent> GroundEvents;
		public Battle Battle { get; set; }
	}

	public class GroundSection
	{
		public Vector3 Position;
		public int SectionID;
		public List<EnemySpawnPointGroup> EnemySpawnPointGroupList;
		public List<GroundObstacle> Obstacles;
		public List<SpawnPointBase> AllEnemySpawnPoints;
		public List<GroundEvent> EventList;
		private bool Progress;
		private Battle battle;
	}

	[Serializable]
	public class GroundFormation
	{
		public int SectionIndex;
		public int Index;
		public bool IgnorePathFind;
		public bool IsEnemy;
		public List<Location> Locations { get; set; }
		public Vector2 Forward { get; set; }
		public Vector2 Center { get; set; }
		public float Height { get; set; }
	}

	public class StatSnapshot
	{
		public StatType Stat { get; set; }
		public long Start { get; set; }
		public long End { get; set; }
	
		[JsonIgnore]
		public long Diff { get; }
	}

	public enum BattleLogCategory
	{
		None = 0,
		Damage = 1,
		Heal = 2,
	}

	public enum BattleLogSourceType
	{
		None = 0,
		Normal = 1,
		Ex = 2,
		Public = 3,
		Passive = 4,
		ExtraPassive = 5,
		Etc = 6,
	}

	[Serializable]
	public struct KillLog : IEquatable<KillLog>
	{
		public int Frame { get; set; }
		public EntityId EntityId { get; set; }
		public bool Equals(KillLog other)
		{
			return default;
		}

	}

	public struct SkillCostRegenSnapshot
	{
		public long Frame { get; set; }
		public float Regen { get; set; }
	}

	public enum TBGHexaObjectSpawnRule
	{
		Nothing = 0,
		ObjectId = 1,
		ObjectType = 2,
	}

	public enum PassiveTriggerEvent
	{
		None = 0,
		BattleEntity_NormalAttack = 2,
		BattleEntity_UseSkillStart = 3,
		BattleEntity_Attack = 4,
		BattleEntity_Damaged = 5,
		BattleEntity_Polling = 6,
		BattleEntity_Heal = 7,
		BattleEntity_Healed = 8,
		BattleEntity_Dying = 9,
		BattleEntity_Attacked = 11,
		BattleEntity_Dodged = 12,
		BattleEntity_AttackCritical = 13,
		BattleEntity_Died = 14,
		BattleEntity_KillEnemy = 15,
		BattleEntity_Reload = 16,
		BattleEntity_UseSkillEnd = 17,
		BattleEntity_AddLogicEffectTemplate = 18,
		BattleEntity_CoverStart = 19,
		BattleEntity_CoverEnd = 20,
		BattleEntity_DamageHit = 21,
		BattleEntity_RemoveLogicEffectTemplate = 22,
		BattleEntity_AddLogicEffectCategory = 23,
		BattleEntity_AddLogicEffectGroupId = 24,
		BattleEntity_RemoveLogicEffectGroupId = 25,
		BattleEntity_KillAlly = 26,
		BattleEntity_CountLogicEffectCategory = 27,
		BattleEntity_UseExSkillCost = 28,
		BattleEntity_AppliedLogicEffectCategory = 29,
		BattleEntity_AppliedLogicEffectGroupId = 30,
		BattleEntity_AppliedLogicEffectTemplate = 31,
		BattleEntity_AppliedLogicEffectData = 32,
		Immediate = 1,
		Battle_Periodic = 105,
		Battle_Polling = 101,
		BattleEntityState_OnOff = 301,
		BattleEntityState_NotMoving = 302,
		BattleEntityState_Reloading = 303,
		BattleEntityState_Moving = 304,
	}

	public class DamageTransferEffect : LogicEffect
	{
		public BasisPoint TransferRatio { get; }
		public int DurationFrame { get; }
		public bool IsDispellable { get; }
		public string TransferredDamageEffectGroupId { get; }
		public int TransferredDamageEffectLevel { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	public class HealConvertDamageEffect : LogicEffect
	{
		public BasisPoint TransferRatio { get; }
		public int Duration { get; }
		public bool Dispellable { get; }
		public string DamageCheckGroupID { get; }
		public string TransferredHealDamageGroupID { get; }
		public bool ApplyDamageRatio { get; }
		public bool ApplyDamageRatio2 { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	public class StackDamageInfo
	{
		private StackDamageEffect stackDamageEffect;
		private BattleEntity invoker;
		private BattleEntity owner;
		private Battle battle;
		private StackDamageProcessor stackDamageProcessor;
		public int Channel { get; }
		public string GroupId { get; }
		public int CurrentStackCount { get; set; }
		public ExpirableObjectHolder<DotAbility> DotAbility { get; }
	}

	public class AccumulateEffectInfo
	{
		private BattleEntity invoker;
		private BattleEntity owner;
		private Battle battle;
		private AccumulateEffectProcessor accumulateEffectProcessor;
		private int StartedFrame;
		public int Channel { get; }
		public string GroupId { get; }
		public ExpirableObjectHolder<DotAbility> DotAbility { get; }
		public AccumulateEffect AccumulateEffect { get; }
		public long AccumulationAmountLimit { get; set; }
		public long AccumulationLimitStat { get; set; }
		public long LastAmount { get; set; }
		public long AddedAmount { get; set; }
		public long CurrentAmount { get; set; }
	}

	public class GaugeEffectInfo
	{
		public List<StatChangeEffect> bindingStatChangeEffects;
		private BattleEntity invoker;
		private GaugeEffectProcessor gaugeEffectProcessor;
		private int StartedFrame;
		public int Channel { get; }
		public string GroupId { get; }
		public ExpirableObjectHolder<DotAbility> DotAbility { get; }
		public ChangeStatLogicApplicationGaugeEffect GaugeEffect { get; }
		public BattleEntity Owner { get; set; }
		public Battle Battle { get; set; }
		public long gaugeValue { get; set; }
		public float GaugePercent { get; }
	}

	public interface IAmplifyDoTEffect
	{
	}

	public enum ManualSkillTypes
	{
		None = 0,
		GroupBuff = 1,
		StrategyBuff = 2,
		EventBuff = 3,
	}

	[Serializable]
	public struct TargetFindRule : IEquatable<TargetFindRule>, IMemoryPackable<TargetFindRule>, IMemoryPackFormatterRegister
	{
		public static readonly TargetFindRule Empty;
		public TargetSortRule Sort;
		public EssentialCandidateRule EssentialCandidate;
		public OptionalCandidateRule OptionalCandidate;
		public bool Equals(TargetFindRule other)
		{
			return default;
		}

	}

	public enum EntitySpawnRule
	{
		SpawnAll = 0,
		SpawnOnlyOne = 1,
		SpawnOnlyOnePerFrame = 2,
	}

	public enum SkillToTargetDistributeType
	{
		None = 0,
		EachToEachTarget = 1,
		AllToOneTarget = 2,
		OneToAllTarget = 3,
	}

	public class SpawnCondition
	{
		public EntitySpawnCondition Condition;
		public string ConditionParameter;
		public EntitySpawnConditionCheckTarget ConditionCheckTarget;
		public Hash64 ConditionParameterHash;
	}

	public enum IncludeType
	{
		None = 0,
		Include = 1,
		Exclude = 2,
	}

	public enum HPRateConstraintType
	{
		None = 0,
		HPOver = 1,
		HPUnder = 2,
	}

	public class TargetProjectileEntityValue : ProjectileEntityValue
	{
		public TargetSideId ExtraHitCheckTargetSide { get; }
		public TargetEntityType ExtraHitCheckTargetEntityType { get; }
		public bool Piercing { get; }
		public int MaxExtraHitCount { get; }
		public long ReduceDamageRatePerHit { get; }
		public long MaxReducedDamageRatePerHit { get; }
	}

	public enum TransitionType
	{
		None = 0,
		Linear = 1,
		EaseIn = 2,
		EaseOut = 3,
		EaseInSine = 4,
		EaseOutSine = 5,
		EaseInOutSine = 6,
		EaseInQuad = 7,
		EaseOutQuad = 8,
		EaseInOutQuad = 9,
		EaseInCubic = 10,
		EaseOutCubic = 11,
		EaseInOutCubic = 12,
		EaseInQuart = 13,
		EaseOutQuart = 14,
		EaseInOutQuart = 15,
		EaseInQuint = 16,
		EaseOutQuint = 17,
		EaseInOutQuint = 18,
		EaseInExpo = 19,
		EaseOutExpo = 20,
		EaseInOutExpo = 21,
		EaseInCirc = 22,
		EaseOutCirc = 23,
		EaseInOutCirc = 24,
		EaseInBack = 25,
		EaseOutBack = 26,
		EaseInOutBack = 27,
		EaseInElastic = 28,
		EaseOutElastic = 29,
		EaseInOutElastic = 30,
		EaseInBounce = 31,
		EaseOutBounce = 32,
		EaseInOutBounce = 33,
	}

	public enum SkillProperty
	{
		None = 0,
		ReuseCoolTime = 1,
		CoolTime = 2,
		CoolTimeAndStartCoolTime = 3,
		ProjectileRange = 4,
		TargetingRange = 5,
		Invalid = 6,
	}

	public enum StatEvalType
	{
		None = 0,
		Base = 1,
		Coefficient = 2,
	}

	[Serializable]
	public struct EchelonConstraint : IMemoryPackable<EchelonConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly EchelonConstraint Empty;
		public CountConstraint CountConstraint;
		public SchoolConstraint SchoolConstraint;
		public WeaponConstraint WeaponConstraint;
		public bool IsEmpty { get; }
	}

	public enum PassiveSkillTargetType
	{
		None = 0,
		UseTriggerSource = 1,
		UseTriggerTarget = 2,
		UseSkillEntityTargetingRule = 3,
		UseTriggerTargetExceptSelf = 4,
	}

	public class BattleExpression : ExpressionContainer
	{
		private Battle battleCache { get; }
		private BattleEntity entity { get; }
		private Character entityAsCharacter { get; }
	}

	public class PartialSelector : BehaviorNode
	{
		private List<BehaviorNode> _behaviors;
		private int _selections;
		public IList<BehaviorNode> Behaviors { get; }
	}

	[Serializable]
	public class GroundPoint : Entity
	{
		public int TileX;
		public int TileY;
		public float PositionHeight;
		public Vector2 Position;
		public Vector2 Direction;
	}

	public enum LogicEffectEndCondition
	{
		None = 0,
		Duration = 1,
		ReloadCount = 2,
		AmmoCount = 3,
		AmmoHit = 4,
		UseExSkillCount = 5,
	}

	public class HealEffect : LogicEffect
	{
		public bool IsAccumulatedHeal { get; }
		public long Amount { get; }
		public StatType BonusSource { get; }
		public BasisPoint BonusRate { get; }
		public ExtraStatType ExtraStatSource { get; }
		public BasisPoint ExtraStatRate { get; }
		public BasisPoint PeriodMultiplier { get; set; }
		public long AddFixedAmount { get; set; }
		public bool TriggerOtherEffect { get; set; }
		public override bool IsDurationChangedByStat { get; }
		public bool ApplyHealRate { get; }
		public bool ApplyHealRateByArmorType { get; }
		public bool ApplyHealRateByBulletType { get; }
	}

	public struct EquipmentOption : IComparable, IComparable<EquipmentOption>, IEquatable<EquipmentOption>
	{
		public EquipmentOptionType OptionType { get; set; }
		public long Value { get; set; }
	
		[JsonIgnore]
		public bool IsValid { get; }
		public int CompareTo(object obj)
		{
			return default;
		}

		public int CompareTo(EquipmentOption other)
		{
			return default;
		}

		public bool Equals(EquipmentOption other)
		{
			return default;
		}

	}

	[Serializable]
	public abstract class SkillEntityDAO : IMemoryPackFormatterRegister
	{
		public string name;
		public string EntityName;
		public long SpawnRate;
		public long SpawnDelay;
		public SkillApplyType ApplyType;
		public TransformDecideTiming DecideTiming;
		public bool EntitySpawnIncludeOutOfRangeInputTarget;
		public SpawnPositionTypes SpawnPositionType;
		public Vector2 SpawnWorldPosition;
		public Vector2 PositionOffset;
		public int PositionRandomOffsetRange;
		public SpawnDirectionTypes OffsetDirectionType;
		public SpawnDirectionTypes SpawnDirectionType;
		public bool OverrideTargetingRule;
		public TargetSortRule TargetSortRule;
		public EssentialCandidateRule EssentialCandidateRule;
		public OptionalCandidateRule OptionalCandidateRule;
		public HighlightOption HighlightOption;
		public bool CheckSpawnPositionMovable;
	}

	public class LevelRootMotionMoveValue : SkillEntityValue
	{
		public TargetEntityType CheckCollisionType;
		public long MoveSpeed;
		public float MoveSpeedInMeter;
		public bool IgnoreMovableCheckInMove;
	}

	[Serializable]
	public class GroundEvent
	{
		public string EventName;
		public OperatorType Operator;
		public List<GroundCondition> Conditions;
		public List<GroundCommand> Commands;
		private bool ended;
		[JsonIgnore]
		public Battle Battle;
	
		[JsonIgnore]
		public int SectionId { get; set; }
	}

	[Serializable]
	public class EnemySpawnPointGroup
	{
		public string GroupName;
		public List<SpawnPointBase> SpawnPoints;
	}

	public abstract class SpawnPointBase : GroundPoint
	{
		public char SpawnAIGroupId;
		public List<string> SpawnConditionIdList;
		public List<string> SpawnCommandIdList;
		public List<SpawnMovePoint> MovePoints;
	
		[JsonIgnore]
		public bool Spawned { get; set; }
	}

	public class Location
	{
		public Vector2 Position { get; set; }
		public Vector2 LocalPosition { get; set; }
		public GroundNode Node { get; set; }
		public FormationLine Line { get; set; }
		public int LineIndex { get; set; }
	}

	public class StackDamageEffect : LogicEffect
	{
		public StackDamageEffectValue StackDamageEffectValue { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	public class AccumulateEffect : LogicEffect
	{
		public AccumulateCheckType AccumulateType { get; }
		public BasisPoint AccumulateRate { get; }
		public TargetSideId AccumulateCasterTargetSideFilter { get; }
		public StatType LimitSourceStat { get; }
		public BasisPoint LimitSourceStatRate { get; }
		public long LimitAmount { get; }
		public ExecuteCondition ExecuteConditionType { get; }
		public long ExecuteConditionAmount { get; }
		public long DurationFrame { get; }
		public List<string> ExecuteLogicEffectGroupIdList { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	public class ChangeStatLogicApplicationGaugeEffect : LogicEffect
	{
		public long MaxGauge;
		private ChangeStatLogicApplicationGaugeEffectValue effectValue;
		public BasisPoint SetGaugeEnergyToTargetHpRatio { get; }
		public BasisPoint StartGaugeEnergyRatio { get; }
		public bool Dispellable { get; }
		public string UIPath { get; }
		public List<AttackLogicEffectType> LogicEffectTypeReduceGauge { get; }
		public override bool IsDurationChangedByStat { get; }
	}

	[Serializable]
	public struct EssentialCandidateRule : IEquatable<EssentialCandidateRule>, IMemoryPackable<EssentialCandidateRule>, IMemoryPackFormatterRegister
	{
		public static readonly EssentialCandidateRule Default;
		public static readonly EssentialCandidateRule Empty;
		public TargetSideId TargetSide;
		public TargetingType TargetingType;
		public TargetEntityType ApplyEntityType;
		public int MaxTargetCount;
	
		[JsonIgnore]
		public bool IsValid { get; }
		public bool Equals(EssentialCandidateRule other)
		{
			return default;
		}

	}

	[Serializable]
	public struct OptionalCandidateRule : IEquatable<OptionalCandidateRule>, IMemoryPackable<OptionalCandidateRule>, IMemoryPackFormatterRegister
	{
		public static readonly OptionalCandidateRule Default;
		public AliveState AliveState;
		public SchoolConstraint SchoolConstraint;
		public WeaponConstraint WeaponConstraint;
		public SquadTypeConstraint SquadTypeConstraint;
		public AdaptationConstraint AdaptationConstraint;
		public BulletConstraint BulletConstraint;
		public TacticRangeConstraint TacticRangeConstraint;
		public TagConstraint TagConstraint;
		public CoverState CoverState;
		public HPRateConstraint HPRateConstraint;
		public TacticRoleConstraint TacticRoleConstraint;
		public bool Equals(OptionalCandidateRule other)
		{
			return default;
		}

	}

	public enum EntitySpawnCondition
	{
		None = 0,
		HPRateUnder = 1,
		HPRateOver = 2,
		IncludeLogicEffectTemplateId = 3,
		ExcludeLogicEffectTemplateId = 4,
		Rate = 5,
		IncludeArmorType = 6,
		ExcludeArmorType = 7,
		SkillLevel = 8,
		IncludeTag = 9,
		ExcludeTag = 10,
	}

	public enum EntitySpawnConditionCheckTarget
	{
		Caster = 0,
		Target = 1,
		SpawnEntityTarget = 2,
	}

	[Serializable]
	public struct CountConstraint : IEquatable<CountConstraint>, IMemoryPackable<CountConstraint>, IMemoryPackFormatterRegister
	{
		public static readonly CountConstraint Empty;
		public int Count;
		public DiffOperatorType DiffOperator;
		public bool Equals(CountConstraint other)
		{
			return default;
		}

	}

	public abstract class ExpressionContainer
	{
		protected Expression expression;
		public Stack<string> StackTrace { get; }
	}

	public abstract class BehaviorNode
	{
		public BehaviorResult Result { get; set; }
	}

	public enum ExtraStatType
	{
		None = 0,
		InvokerCurrentHP = 1,
		TargetCurrentHP = 2,
		InvokerMaxHP = 3,
		TargetMaxHP = 4,
		InvokerLostHP = 5,
		TargetLostHP = 6,
		InvokerMaxHPCapGaugeValue = 7,
		TargetMaxHPCapGaugeValue = 8,
		InvokerDefaultDefense = 9,
		TargetDefaultDefense = 10,
		InvokerCurrentDefense = 11,
		TargetCurrentDefense = 12,
	}

	public enum HighlightOption
	{
		None = 0,
		Highlight = 1,
		HighlightAndFactor = 2,
	}

	public enum OperatorType
	{
		AND = 0,
		OR = 1,
	}

	[Serializable]
	public abstract class GroundCondition
	{
		public string ConditionID;
		[JsonIgnore]
		protected GroundEvent Event;
	
		[JsonIgnore]
		public bool Achieve { get; set; }
	}

	[Serializable]
	public class GroundCommand
	{
		public string CommandID;
		[JsonIgnore]
		public GroundEvent Event;
		[JsonIgnore]
		public Action<Battle> VisualizeDelegate;
		public bool WaitExecuteEnd { get; set; }
	
		[JsonIgnore]
		public bool Progress { get; set; }
	}

	public class StackDamageEffectValue : LogicEffectValue
	{
		public ValueTuple<string, int, long, long>[] ApplyLogifEffectList;
		public string StackCountGroupId { get; }
		public int ActuateStackCount { get; }
		public string ActuateGroupId { get; }
		public long DurationFrame { get; }
		public bool Dispellable { get; }
		public int Level { get; }
	}

	public enum AccumulateCheckType
	{
		Damage = 0,
		Heal = 1,
	}

	public enum ExecuteCondition
	{
		OverAccumulateAmount = 0,
		OverDuration = 1,
	}

	public class ChangeStatLogicApplicationGaugeEffectValue : LogicEffectValue
	{
		public BasisPoint SetGaugeEnergyToTargetHpRatio { get; }
		public BasisPoint StartGaugeEnergyRatio { get; }
		public bool Dispellable { get; }
		public List<AttackLogicEffectType> LogicEffectTypeReduceGauge { get; }
		public string UIPath { get; }
	}

	public enum DiffOperatorType
	{
		None = 0,
		GreaterOrEqual = 1,
		LessOrEqual = 2,
		Equal = 3,
		NotEqual = 4,
	}

	public class Expression
	{
		private static bool _cacheEnabled;
		private static Dictionary<string, WeakReference> _compiledExpressions;
		private static readonly ReaderWriterLock Rwl;
		protected Dictionary<string, IEnumerator> ParameterEnumerators;
		protected Dictionary<string, object> ParametersBackup;
		private EvaluateFunctionHandler EvaluateFunction;
		private EvaluateParameterHandler EvaluateParameter;
		private Dictionary<string, object> _parameters;
		private Stack<string> stackTrace;
		public EvaluateOptions Options { get; set; }
		protected string OriginalExpression { get; }
		public static bool CacheEnabled { get; set; }
		public string Error { get; set; }
		public LogicalExpression ParsedExpression { get; set; }
		public Dictionary<string, object> Parameters { get; set; }
		public Stack<string> StackTrace { get; }
	}

	public sealed class EvaluateFunctionHandler
	{
	}

	public sealed class EvaluateParameterHandler
	{
	}

	public enum EvaluateOptions
	{
		None = 1,
		IgnoreCase = 2,
		NoCache = 4,
		IterateParameters = 8,
		RoundAwayFromZero = 16,
	}

	public abstract class LogicalExpression
	{
		private const char BS = '\\';
	}


	public struct Vector2
	{
		public float x { get; set; }
		public float y { get; set; }
	}


    public struct Vector3
    {
        public float x { get; set; }
        public float y { get; set; }
        public float z { get; set; }
    }


    public interface IMemoryPackFormatterRegister
    {
    }


    public interface IMemoryPackable<T>
    {
    }


	public class TypedJsonWrapper<T> where T : class
	{
		public string JsonWithType { get; set; }
	}


    public class ExpirableObjectHolder<T> : IEquatable<ExpirableObjectHolder<T>>
    {
        public T Value { get; set; }

        public int Elapsed { get; set; }

        public int DurationFrame { get; set; }

        public int RemainDuration { get; set; }

        public bool IsExpired { get; set; }

        public bool IsRemoved { get; set; }

        public bool IsDispelled { get; set; }

        private Character OwnerCharacter { get; set; }

        private BattleEntity OwnerBattleEntity { get; set; }

        public bool Equals(ExpirableObjectHolder<T>? other)
        {
            return false;
        }
    }


	public class EntityCollection<T> : SortedDictionary<EntityId, T> where T : Entity
	{

	}

}