| 
| enum   | BattleCameraType { None, 
BlockSchematics, 
AllowSchematics
 } | 
|   | 
| enum   | GridSelectionType {  
  None, 
Placement, 
Orientation, 
Move, 
 
  Examine, 
Target, 
Custom
 
 } | 
|   | 
| enum   | SlotInventoryType { Disable, 
Enable, 
PlayerOnly
 } | 
|   | 
| enum   | ShortcutOncePerListMode { None, 
Prevent, 
Remove
 } | 
|   | 
| enum   | MarkNewContentType { None, 
FirstAdd, 
EachAdd, 
EachChange
 } | 
|   | 
| enum   | UnmarkNewContentType { None, 
View, 
Selection
 } | 
|   | 
| enum   | BattleControlBlock { None, 
Battle, 
AllActions, 
PlayerActions
 } | 
|   | 
| enum   | AllowTurnControl { None, 
Always, 
WhileChoosing, 
WhileInAction
 } | 
|   | 
| enum   | StatusValueOrigin { Base, 
Current, 
Maximum, 
ToMaximum
 } | 
|   | 
| enum   | StatDevType { None, 
Curve, 
Formula, 
Percent
 } | 
|   | 
| enum   | LevelUpType { None, 
Auto, 
Spend, 
Uses
 } | 
|   | 
| enum   | CostType { StatusValue, 
Item
 } | 
|   | 
| enum   | ResearchItemDuration { None, 
Manual, 
Time
 } | 
|   | 
| enum   | ResearchTreeStateCheck { Known, 
Unknown, 
Complete
 } | 
|   | 
| enum   | ResearchItemState { Unresearched, 
InResearch, 
Researched, 
Complete
 } | 
|   | 
| enum   | ResearchSelection { All, 
ResearchType, 
ResearchTree, 
ResearchItem
 } | 
|   | 
| enum   | ResearchDisplayType {  
  Researchable, 
LimitFail, 
CostsFail, 
RequirementsFail, 
 
  InResearch, 
Complete
 
 } | 
|   | 
| enum   | CombatantScope { Group, 
Individual
 } | 
|   | 
| enum   | InventoryAddType { Add, 
AutoStack, 
AutoSplit
 } | 
|   | 
| enum   | PlayerSpawnTarget {  
  SpawnPoint, 
Position, 
Object, 
LastPosition, 
 
  ScenePosition
 
 } | 
|   | 
| enum   | StoreGridCellType { BattleRangeTemplate, 
Custom, 
Path
 } | 
|   | 
| enum   | DataStoreType { Save, 
Load, 
Clear
 } | 
|   | 
| enum   | ActorAlliedCheckType { Player, 
MachineObject, 
StartingObject
 } | 
|   | 
| enum   | CombatantSelectionDialogueType {  
  Defined, 
BattleGroup, 
NonBattleGroup, 
LockedBattleGroup, 
 
  Members, 
InactiveMembers, 
HiddenMembers, 
BattleReserve
 
 } | 
|   | 
| enum   | LootVariableOrigin { Global, 
Combatant, 
Spawner
 } | 
|   | 
| enum   | LootTableSelectionType { All, 
First, 
Random
 } | 
|   | 
| enum   | LootTableDrawType { All, 
Random, 
Pool
 } | 
|   | 
| enum   | LootDropReplacement { None, 
Auto, 
Conditions
 } | 
|   | 
| enum   | MoveAnimationMode {  
  None, 
Idle, 
Walk, 
Run, 
 
  Sprint, 
Jump, 
Fall, 
Land, 
 
  ActionChooseIdle, 
ActionWaitIdle, 
ActionCastIdle, 
TurnEndedIdle
 
 } | 
|   | 
| enum   | MecanimRotationType { FullDegree, 
Direction4, 
Direction8
 } | 
|   | 
| enum   | SceneIDChangeType { Item, 
Battle
 } | 
|   | 
| enum   | CursorType {  
  Custom, 
Default, 
TargetSelfValid, 
TargetAllyValid, 
 
  TargetEnemyValid, 
TargetAllValid, 
TargetSelfInvalid, 
TargetAllyInvalid, 
 
  TargetEnemyInvalid, 
TargetAllInvalid, 
TargetSelfNone, 
TargetAllyNone, 
 
  TargetEnemyNone, 
TargetAllNone, 
AttackRange, 
InActionPlayer, 
 
  InActionAlly, 
InActionEnemy, 
GridPlacementSelection, 
GridNoPlacementSelection, 
 
  GridMoveSelection, 
GridNoMoveSelection, 
GridOrientationSelection, 
GridExamineSelection, 
 
  GridExamineSelectionBlocked
 
 } | 
|   | 
| enum   | MenuCombatantScope {  
  Current, 
Battle, 
Group, 
NonBattle, 
 
  BattleReserve, 
GroupBattleSorted, 
NonBattleReserve
 
 } | 
|   | 
| enum   | GroupMenuCombatantScope { Battle, 
NonBattle, 
Both
 } | 
|   | 
| enum   | MenuTypeDisplay { None, 
UIBox, 
Merged, 
Tabs
 } | 
|   | 
| enum   | MenuTypeDisplayNoMerge { None, 
UIBox, 
Tabs
 } | 
|   | 
| enum   | MenuBoxDisplay { Same, 
One, 
Multi, 
Sequence
 } | 
|   | 
| enum   | MenuStatus { Opening, 
Opened, 
Closing, 
Closed
 } | 
|   | 
| enum   | CraftingListCreationType { Exact, 
One, 
Multi, 
ExactOrder
 } | 
|   | 
| enum   | MenuDetailsBoxMode { None, 
Use, 
Info, 
HUD
 } | 
|   | 
| enum   | QuantitySelectionMode {  
  Remove, 
Drop, 
Give, 
Buy, 
 
  Sell
 
 } | 
|   | 
| enum   | QuantityType { Default, 
One, 
All, 
Select
 } | 
|   | 
| enum   | BMTypeDisplay { Combined, 
Type, 
List
 } | 
|   | 
| enum   | BattleMenuMode {  
  None, 
List, 
AbilityType, 
Ability, 
 
  ItemType, 
Item, 
Target, 
EquipmentSlot, 
 
  Equipment, 
Command, 
ChangeMember, 
AIType, 
 
  AIBehaviourSlot, 
AIBehaviour, 
AIRulesetSlot, 
AIRuleset, 
 
  GridMove, 
GridOrientation, 
GridExamine, 
Reset, 
 
  Back, 
ClassSlot, 
ClassSlotClass, 
ClassSingle
 
 } | 
|   | 
| enum   | BattleMenuTargetSelectionMode { AfterAction, 
BeforeAction
 } | 
|   | 
| enum   | BestiaryLearnType {  
  None, 
Encounter, 
Attack, 
AttackedBy, 
 
  Death
 
 } | 
|   | 
| enum   | ShopMode { Buy, 
Sell, 
Exit
 } | 
|   | 
| enum   | ShopTypeDisplay { UIBox, 
Tabs, 
Merged
 } | 
|   | 
| enum   | StatisticType {  
  TotalKilled, 
SingleKilled, 
TotalUsed, 
SingleUsed, 
 
  TotalCreated, 
SingleCreatedItem, 
SingleCreatedEquipment, 
TotalBattles, 
 
  WonBattles, 
LostBattles, 
EscapedBattles, 
Custom, 
 
  SingleCreatedAIBehaviour, 
SingleCreatedAIRuleset, 
SingleCreatedCraftingRecipes, 
TotalGained, 
 
  SingleGainedItem, 
SingleGainedEquipment, 
SingleGainedAIBehaviour, 
SingleGainedAIRuleset, 
 
  SingleGainedCraftingRecipes
 
 } | 
|   | 
| enum   | ValueSetter { Percent, 
Value
 } | 
|   | 
| enum   | Consider { Yes, 
No, 
Ignore
 } | 
|   | 
| enum   | ShortcutListChange { Next, 
Previous, 
DefinedIndex
 } | 
|   | 
| enum   | RequirementTargetType { None, 
User, 
Target
 } | 
|   | 
| enum   | GroupMemberSelectionType { Combatant, 
Leader, 
Index, 
Offset
 } | 
|   | 
| enum   | SimpleChangeType { Add, 
Remove
 } | 
|   | 
| enum   | StatusValueType { Normal, 
Consumable, 
Experience
 } | 
|   | 
| enum   | StatusValueDeathType { None, 
OnMinimum, 
OnMaximum
 } | 
|   | 
| enum   | ExperienceType { None, 
Level, 
ClassLevel
 } | 
|   | 
| enum   | StatusValueGetValue {  
  CurrentValue, 
BaseValue, 
MinValue, 
MaxValue, 
 
  DisplayValue, 
PreviewValue, 
PreviewMaxValue, 
PreviewMinValue, 
 
  LastChangeValue, 
LastCombinedChangeValue, 
LastCombinedChangeValuePositive, 
LastCombinedChangeValueNegative
 
 } | 
|   | 
| enum   | UpgradeDisplayType { Upgradeable, 
CostsFail, 
ConditionsFail, 
NoUpgrade
 } | 
|   | 
| enum   | NoneExperienceMaxType { NextLevel, 
CurrentLevel, 
MaxValue
 } | 
|   | 
| enum   | EndAfterType {  
  None, 
TurnStart, 
TurnEnd, 
Time, 
 
  ActionStart, 
ActionEnd, 
BattleTurnStart, 
BattleTurnEnd, 
 
  PhaseStart, 
PhaseEnd, 
Custom, 
StatusValueChange, 
 
  SelectedAsTarget, 
Death
 
 } | 
|   | 
| enum   | EffectRecast { Add, 
Reset, 
None
 } | 
|   | 
| enum   | EffectStacking { None, 
Enabled, 
OncePerCombatant, 
SingleInstance
 } | 
|   | 
| enum   | EffectStatusValueSetOn {  
  Apply, 
Remove, 
TurnStart, 
TurnEnd, 
 
  Time, 
ActionStart, 
ActionEnd, 
BattleTurnStart, 
 
  BattleTurnEnd, 
PhaseStart, 
PhaseEnd, 
Custom, 
 
  StatusValueChange, 
SelectedAsTarget, 
Death
 
 } | 
|   | 
| enum   | EffectRemoveOrigin {  
  Duration, 
EndWithBattle, 
EndOnAttack, 
EndOnDeath, 
 
  EndOnAbility, 
EndOnItem, 
Other
 
 } | 
|   | 
| enum   | EffectLocalDataType { Cast, 
CopyCast, 
CopyCastNew, 
New
 } | 
|   | 
| enum   | ChangeBlock { None, 
Negative, 
Positive, 
All
 } | 
|   | 
| enum   | EffectChangeBlock { None, 
Add, 
Remove, 
All
 } | 
|   | 
| enum   | EffectCast { Add, 
Remove, 
Toggle
 } | 
|   | 
| enum   | EffectTypeRemoveType { All, 
Random, 
First, 
Last
 } | 
|   | 
| enum   | TargetType { Self, 
Ally, 
Enemy, 
All
 } | 
|   | 
| enum   | TargetRange { None, 
Single, 
Group
 } | 
|   | 
| enum   | UseableIn { Field, 
Battle, 
Both, 
None
 } | 
|   | 
| enum   | AbilityCheckType { Known, 
Learned, 
GroupAbility, 
Temporary
 } | 
|   | 
| enum   | IncludeCheckType { Yes, 
No, 
Only
 } | 
|   | 
| enum   | ItemAbilityType { None, 
Learn, 
Use
 } | 
|   | 
| enum   | UseCostAutoConsumeType { No, 
WithoutTargets, 
Always, 
OnSelection
 } | 
|   | 
| enum   | UseCostCalculationMomentType { BeforeTargets, 
AfterTargets
 } | 
|   | 
| enum   | BattleRangeType { None, 
Template, 
Custom
 } | 
|   | 
| enum   | AffectRangeType { None, 
Calculation, 
Execution
 } | 
|   | 
| enum   | ActionReuseStartType { Start, 
Calculation, 
End
 } | 
|   | 
| enum   | TargetSelectionSortType { None, 
Distance, 
ScreenPosition
 } | 
|   | 
| enum   | EquipType { Single, 
Multi
 } | 
|   | 
| enum   | EquipmentDurabilityType {  
  NoBonuses, 
Unequip, 
Destroy, 
None, 
 
  Schematic
 
 } | 
|   | 
| enum   | BlockedSlotDisplayType { Show, 
Inactive, 
Hidden
 } | 
|   | 
| enum   | PlayerType { Current, 
Field, 
Battle
 } | 
|   | 
| enum   | AggressionType { Always, 
OnDamage, 
OnSelection, 
OnAction
 } | 
|   | 
| enum   | CombatantAffiliationType { Player, 
Ally, 
Enemy
 } | 
|   | 
| enum   | CombatantDeathState { Alive, 
Dying, 
Dead
 } | 
|   | 
| enum   | FoundTargets { Keep, 
Check, 
Clear, 
CheckKeep
 } | 
|   | 
| enum   | MoveDetectionType { Sight, 
Movement, 
CombatantTrigger
 } | 
|   | 
| enum   | MoveAIMode {  
  Idle, 
Waypoint, 
Follow, 
GiveWay, 
 
  Hunt, 
Flee, 
CautionHunt, 
CautionFlee, 
 
  Protect
 
 } | 
|   | 
| enum   | MoveAIUseMode {  
  Auto, 
Idle, 
Hunt, 
Flee, 
 
  Caution, 
Protect
 
 } | 
|   | 
| enum   | BattleAITargetType {  
  Self, 
Ally, 
Enemy, 
All, 
 
  None
 
 } | 
|   | 
| enum   | BattleAISelectedDataUser {  
  Self, 
Ally, 
Enemy, 
All, 
 
  FoundTargets
 
 } | 
|   | 
| enum   | AIGridMove {  
  MoveTowardTarget, 
FleeFromTarget, 
Random, 
GridFormation, 
 
  GridCellType
 
 } | 
|   | 
| enum   | AIGridMoveTargetType {  
  Nearest, 
North, 
East, 
South, 
 
  West, 
Front, 
Back, 
Left, 
 
  Right
 
 } | 
|   | 
| enum   | AIGridMoveRangeType { Distance, 
BattleRangeTemplate, 
Custom, 
UseRange
 } | 
|   | 
| enum   | AIRuleType {  
  Action, 
BattleAI, 
BlockAbility, 
BlockAttack, 
 
  BlockCounterAttack, 
BlockItem, 
Target, 
MoveAI
 
 } | 
|   | 
| enum   | AIRuleTargetType {  
  Self, 
Ally, 
Enemy, 
All, 
 
  MemberTarget, 
TargetingMember
 
 } | 
|   | 
| enum   | BattleAITargetOrigin {  
  User, 
Leader, 
Group, 
Allies, 
 
  Enemies, 
FoundTargets, 
SelectedData
 
 } | 
|   | 
| enum   | WeightedGroupType { Smallest, 
Largest
 } | 
|   | 
| enum   | DistanceType {  
  Nearest, 
NearestAverage, 
Farthest, 
FarthestAverage, 
 
  All
 
 } | 
|   | 
| enum   | BattleSystemType { TurnBased, 
ActiveTime, 
RealTime, 
Phase
 } | 
|   | 
| enum   | TurnBasedMode { Classic, 
Active, 
MultiTurns
 } | 
|   | 
| enum   | TargetRayOrigin { User, 
Screen
 } | 
|   | 
| enum   | EnemyCounting { None, 
Letters, 
Numbers
 } | 
|   | 
| enum   | EnemyCountingType { ID, 
Name
 } | 
|   | 
| enum   | UseTimebarAction { ActionBorder, 
MaxTimebar, 
EndTurn
 } | 
|   | 
| enum   | GroupAdvantageType { None, 
Player, 
Enemy
 } | 
|   | 
| enum   | BattleOutcome {  
  None, 
Victory, 
Escape, 
Defeat, 
 
  LeaveArena
 
 } | 
|   | 
| enum   | ActionTimeDecreaseType { Always, 
WhileChoosing, 
WhileInAction
 } | 
|   | 
| enum   | PhaseTurnStartType { None, 
PhaseStart, 
PhaseEnd
 } | 
|   | 
| enum   | BattleGridType { Square, 
Hexagonal
 } | 
|   | 
| enum   | HexagonalGridType { VerticalEven, 
VerticalOdd, 
HorizontalEven, 
HorizontalOdd
 } | 
|   | 
| enum   | GridBaseHighlight { Area, 
Selection, 
NoSelection
 } | 
|   | 
| enum   | GridCellHighlight {  
  None, 
Placement, 
PlacementSelection, 
NoPlacementSelection, 
 
  PlacementSelectionPlayer, 
PlacementSelectionAlly, 
PlacementSelectionEnemy, 
MoveRange, 
 
  MoveRangeBlocked, 
MoveRangePassable, 
MoveSelection, 
NoMoveSelection, 
 
  MovePath, 
MoveSelectionPlayer, 
MoveSelectionAlly, 
MoveSelectionEnemy, 
 
  OrientationSelection, 
OrientationSelectionPlayer, 
OrientationSelectionAlly, 
OrientationSelectionEnemy, 
 
  MarkedCell, 
UseRange, 
AffectRange, 
AvailableTargetPlayer, 
 
  AvailableTargetAlly, 
AvailableTargetEnemy, 
SelectedTargetPlayer, 
SelectedTargetAlly, 
 
  SelectedTargetEnemy, 
TargetCellSelection, 
NoTargetCellSelection, 
TargetCellSelectionPlayer, 
 
  TargetCellSelectionAlly, 
TargetCellSelectionEnemy, 
ExamineSelection, 
ExamineSelectionBlocked, 
 
  ExamineMoveRange, 
ExamineMoveRangeBlocked, 
ExamineMoveRangePassable, 
ExamineUseRange, 
 
  ExamineSelectionPlayer, 
ExamineSelectionAlly, 
ExamineSelectionEnemy, 
SelectingPlayer, 
 
  SelectingAlly, 
SelectingEnemy, 
CellPlayer, 
CellPlayerTurnEnded, 
 
  CellAlly, 
CellAllyTurnEnded, 
CellEnemy, 
CellEnemyTurnEnded, 
 
  GridFormation, 
GridFormationPosition, 
Custom1, 
Custom2, 
 
  Custom3, 
Custom4, 
Custom5, 
WaypointCell, 
 
  WaypointPath
 
 } | 
|   | 
| enum   | GridShapeType {  
  None, 
All, 
Range, 
Mask, 
 
  Ring
 
 } | 
|   | 
| enum   | GridUseBattleType { NoGrid, 
NearestGrid, 
DefinedGrid
 } | 
|   | 
| enum   | GridPathCellSelection { Next, 
Last, 
All
 } | 
|   | 
| enum   | GridDirectionRotationType { Nearest, 
Left, 
Right, 
Target
 } | 
|   | 
| enum   | GridCellEventStartType {  
  None, 
Any, 
MoveTo, 
MoveOver, 
 
  StartTurn, 
EndTurn, 
MoveFrom
 
 } | 
|   | 
| enum   | SetCellCombatantType { Combatant, 
Guest, 
Move, 
Remove
 } | 
|   | 
| enum   | GridMoveState { Available, 
Selected, 
Performed
 } | 
|   | 
| enum   | AutoGridMoveType { None, 
FirstAction, 
Always
 } | 
|   | 
| enum   | ActionSelectType {  
  Attack, 
CounterAttack, 
Ability, 
Item, 
 
  Defend, 
Escape, 
Death, 
None, 
 
  ChangeMember, 
ClassAbility, 
Shortcut, 
AbilityType, 
 
  ItemType, 
InventoryContainerSlot
 
 } | 
|   | 
| enum   | ActionType {  
  Attack, 
CounterAttack, 
Ability, 
Item, 
 
  Defend, 
Escape, 
Death, 
None, 
 
  ChangeMember, 
Join, 
GridMove
 
 } | 
|   | 
| enum   | AbilityActionType { Ability, 
BaseAttack, 
CounterAttack
 } | 
|   | 
| enum   | AutoAttackTargetType { All, 
GroupTargets, 
IndividualTargets, 
GroupAndIndividual
 } | 
|   | 
| enum   | BattleActionAddType { Try, 
NextAction, 
SubAction, 
OutsideBattleOrder
 } | 
|   | 
| enum   | NextBattleActionChange { Add, 
Set, 
First
 } | 
|   | 
| enum   | BaseAttackScope { Current, 
Index, 
All
 } | 
|   | 
| enum   | CombatantActionState { Available, 
Casting, 
InAction, 
EndingAction
 } | 
|   | 
| enum   | CombatantTurnState { BeforeTurn, 
InTurn, 
AfterTurn
 } | 
|   | 
| enum   | CastingScopeCheck { Single, 
Type, 
RootType, 
All
 } | 
|   | 
| enum   | QuestStatusType { Inactive, 
Active, 
Finished, 
Failed
 } | 
|   | 
| enum   | QuestCheckType {  
  Inactive, 
Active, 
Finished, 
Failed, 
 
  NotAdded
 
 } | 
|   | 
| enum   | QuestRemoveType { Quest, 
QuestType, 
All, 
SelectedData
 } | 
|   | 
| enum   | ControlMapKeyType { Action, 
AutoAttack, 
GlobalMachine, 
Schematic
 } | 
|   | 
| enum   | CameraControlType {  
  None, 
Follow, 
Look, 
Mouse, 
 
  FirstPerson, 
TopDownBorder
 
 } | 
|   | 
| enum   | ButtonControlMoveType { CharacterController, 
NavMeshAgent, 
CombatantMovementComponent, 
AnimatorRootMotion
 } | 
|   | 
| enum   | MouseControlMoveType { CharacterController, 
NavMeshAgent, 
CombatantMovementComponent
 } | 
|   | 
| enum   | PlayerControlType { None, 
Button, 
Mouse, 
TopDown2D
 } | 
|   | 
| enum   | CombatantLevelCheckType { None, 
Base, 
Class
 } | 
|   | 
| enum   | StatusConditionType { Status, 
Conditions, 
Template
 } | 
|   | 
| enum   | CustomSettingsUseSource { Source, 
User, 
Target
 } | 
|   | 
| enum   | SelectCombatantType {  
  Combatant, 
GroupTarget, 
IndividualTarget, 
LastTarget, 
 
  AttackedBy, 
KilledBy, 
Linked, 
Attacked
 
 } | 
|   | 
| enum   | UseTargetChanges { All, 
One, 
None
 } | 
|   | 
| enum   | BattleActionResult { Hit, 
Critical, 
Miss, 
Block
 } | 
|   | 
| enum   | CombatantBattleActionResult {  
  None, 
Hit, 
Critical, 
Miss, 
 
  Block
 
 } | 
|   | 
| enum   | BattleCameraDistanceOrigin { User, 
CameraControlTarget, 
Player, 
Arena
 } | 
|   | 
| enum   | CameraLookAtType { SimpleLook, 
CameraPosition, 
CameraControlTarget, 
Schematic
 } | 
|   | 
| enum   | LootStoreType { BattleLoot, 
ItemBoxID, 
ItemBoxObject, 
SelectedData
 } | 
|   | 
| enum   | GridCellEventType { Ability, 
StatusEffect, 
Schematic
 } | 
|   | 
| enum   | GridDeploymentType {  
  None, 
Player, 
Ally, 
Enemy, 
 
  All, 
Faction, 
Combatant
 
 } | 
|   | 
| enum   | BattleGridFormationLeaderDeath { Keep, 
Break, 
Select
 } | 
|   | 
| enum   | BattleGridFormationRotation { None, 
Leader, 
Select
 } | 
|   | 
| enum   | ConsiderFormationCombatants { None, 
All, 
IgnoreFormation
 } | 
|   | 
| enum   | MoveRangeType { Current, 
Max, 
All
 } | 
|   | 
| enum   | DamageDealerAutoActivationType { None, 
SetAction, 
Activate
 } | 
|   | 
| enum   | BattleAnimationType {  
  Ability, 
Item, 
Defend, 
Escape, 
 
  Death, 
None, 
Retreat, 
EnterBattle, 
 
  JoinBattle, 
GridMove, 
AbilityStart, 
AbilityEnd, 
 
  ItemStart, 
ItemEnd
 
 } | 
|   | 
| enum   | ReuseType { Turn, 
Time, 
BattleStart, 
BattleEnd
 } | 
|   | 
| enum   | UseRangeOriginType {  
  Attack, 
CounterAttack, 
Ability, 
ClassAbility, 
 
  Item, 
ShortcutSlot, 
BattleRangeTemplate, 
Custom, 
 
  SelectedData
 
 } | 
|   | 
| enum   | TargetRaycastAutoTargetType { Screen, 
User, 
Target
 } | 
|   | 
| enum   | TargetRaycastType { None, 
Default, 
Custom
 } | 
|   | 
| enum   | TargetSelectionType {  
  Template, 
Custom, 
DefaultEnemySingle, 
DefaultEnemyGroup, 
 
  DefaultEnemyNone, 
DefaultAllySingle, 
DefaultAllyGroup, 
DefaultAllyNone, 
 
  DefaultAllSingle, 
DefaultAllGroup, 
DefaultAllNone, 
DefaultSelf
 
 } | 
|   | 
| enum   | UseBlockType { Ability, 
Item, 
Both
 } | 
|   | 
| enum   | UseBlockScope {  
  Single, 
Type, 
RootType, 
All, 
 
  Custom
 
 } | 
|   | 
| enum   | BodyPartObjectType { Parent, 
Empty, 
Prefab
 } | 
|   | 
| enum   | FindGroundType { None, 
CharacterController, 
Raycast
 } | 
|   | 
| enum   | GroupSelectionType { ActivePlayerGroup, 
PlayerGroupID, 
Combatant
 } | 
|   | 
| enum   | CombatantLootOrigin { None, 
StartInventory, 
Loot, 
Both
 } | 
|   | 
| enum   | DropItemPrefabType { None, 
Use, 
CollectorSpawn
 } | 
|   | 
| enum   | AvailableEquipmentSelectionType {  
  Default, 
All, 
Template, 
Custom, 
 
  None
 
 } | 
|   | 
| enum   | EquipmentSlotSetType { Template, 
Custom
 } | 
|   | 
| enum   | InventorySpaceCheckType {  
  IsEmpty, 
IsFull, 
OccupiedSpace, 
TotalSpace, 
 
  RemainingSpace
 
 } | 
|   | 
| enum   | AbilityState {  
  None, 
BaseAttack, 
CounterAttack, 
Class, 
 
  Learned, 
Equipment, 
Temporary, 
Group, 
 
  LearnedClassSlot, 
GroupClassSlot
 
 } | 
|   | 
| enum   | ShortcutCheckType { Any, 
Type, 
Defined
 } | 
|   | 
| enum   | ShortcutType {  
  Empty, 
Item, 
Equipment, 
Currency, 
 
  Ability, 
Attack, 
CounterAttack, 
Defend, 
 
  Escape, 
None, 
GridMove, 
GridOrientation, 
 
  GridExamine, 
CraftingRecipe, 
AIBehaviour, 
AIRuleset
 
 } | 
|   | 
| enum   | ShortcutAbilityLinkType { BaseAttack, 
CounterAttack
 } | 
|   | 
| enum   | PassiveAbilityStateType { AlwaysEnabled, 
StartEnabled, 
StartDisabled
 } | 
|   | 
| enum   | AutoAttackType {  
  None, 
BaseAttack, 
CounterAttack, 
Ability, 
 
  ShortcutSlotAbility
 
 } | 
|   | 
| enum   | TemporaryAbilityRemoveType {  
  None, 
Turn, 
Time, 
BattleStart, 
 
  BattleEnd
 
 } | 
|   | 
| enum   | AddRandomBonus { All, 
Random, 
First, 
ChanceSelection
 } | 
|   | 
| enum   | CombatantLevelInitType {  
  Default, 
Player, 
Random, 
Variable, 
 
  Formula
 
 } | 
|   | 
| enum   | StatusValueDistributionPointsType { Value, 
Experience, 
Item
 } | 
|   | 
| enum   | ModifierListType {  
  Defined, 
Strength, 
Weakness, 
Immunity, 
 
  Recovery, 
All
 
 } | 
|   | 
| enum   | ModifierAttributeListType {  
  All, 
Strength, 
Weakness, 
Immunity, 
 
  Recovery
 
 } | 
|   | 
| enum   | ModifierTraitType {  
  None, 
Strength, 
Weakness, 
Immunity, 
 
  Recovery
 
 } | 
|   | 
| enum   | ModifierGetValue {  
  CurrentValue, 
BaseValue, 
MinValue, 
MaxValue, 
 
  StartValue, 
PreviewValue
 
 } | 
|   | 
| enum   | EffectModifierUseType { None, 
Add, 
Replace, 
AddReplace
 } | 
|   | 
| enum   | ModifierCalculationType {  
  Continuously, 
PerAttribute, 
PerAttributeDivided, 
Highest, 
 
  Lowest
 
 } | 
|   | 
| enum   | EffectAppliedDurationCheckType {  
  Turns, 
BattleTurns, 
Time, 
Actions, 
 
  Phases, 
Custom
 
 } | 
|   | 
| enum   | StatusValueNotificationType {  
  NormalSet, 
NormalAdd, 
CriticalSet, 
CriticalAdd, 
 
  Blocked
 
 } | 
|   | 
| enum   | UseCountResetType {  
  All, 
BattleStart, 
BattleEnd, 
TurnStart, 
 
  TurnEnd
 
 } | 
|   | 
| enum   | QuestTaskSelectionType { QuestTask, 
Quest, 
QuestType, 
All
 } | 
|   | 
| enum   | RotateToTargetType {  
  Center, 
Nearest, 
First, 
Last, 
 
  Random
 
 } | 
|   | 
| enum   | BodyPartTargetListingType { WithTargets, 
SubMenu, 
SubMenuForAll
 } | 
|   | 
| enum   | HUDActionCombatantType { User, 
Target
 } | 
|   | 
| enum   | HUDStatusEffectOriginType { Current, 
Preview, 
OnlyPreviewAdd, 
OnlyPreviewRemove
 } | 
|   | 
| enum   | HUDStatusOriginType {  
  Current, 
Preview, 
PreviewHide, 
PreviewHideNoChange, 
 
  PreviewHideChange
 
 } | 
|   | 
| enum   | InputRebindSameType { Keep, 
NoneInput, 
Switch
 } | 
|   | 
| enum   | NumberFormatType { Int, 
Float
 } | 
|   | 
| enum   | NumberFormatManipulator { None, 
Operator, 
Formula
 } | 
|   |