pub enum AIDifficulty {
  Easy_
  Normal_
  Hard_
  Nightmare_
} derive(Eq)

pub struct Achievement {
  id : String
  name : String
  description : String
  category : AchievementCategory
  is_secret : Bool
  points : Int
}

pub enum AchievementCategory {
  Combat
  Collection
  Mastery
  Challenge
  Secret
} derive(Eq)

pub struct ActiveAbility {
  id : String
  card_id : String
  name : String
  effect : String
}

pub struct ArchetypeGuide {
  name : String
  description : String
  key_cards : Array[String]
  playstyle : String
  strengths : String
  weaknesses : String
  recommended_relic : String
}

pub struct BattleMetrics {
  turns_played : Int
  total_damage_dealt : Int
  total_damage_taken : Int
  total_armor_gained : Int
  total_sonic_boom_applied : Int
  cards_played : Int
  abilities_activated : Int
  pollution_peak : Int
  victory : Bool
}

pub enum BattlePhase {
  PlayerTurn
  EnemyTurn
  Victory_
  Defeat_
} derive(Eq, Show)

pub struct BattleReplay {
  character_id : String
  enemy_id : String
  frames : Array[ReplayFrame]
  total_frames : Int
  result : String
  duration : Int
  version : String
}

pub struct BattleState {
  player : PlayerState
  enemy : EnemyState
  player_char : Character
  enemy_data : Enemy
  phase : BattlePhase
  turn_number : Int
  pollution : Int
  log : Array[String]
}

pub enum BossRushState {
  NotStarted
  InProgress
  Completed_
  Failed
} derive(Eq)

pub struct Card {
  id : String
  name : String
  name_en : String
  card_type : CardType
  archetype : CardArchetype
  cost : Int
  target : CardTarget
  effect : String
  design_note : String
  base_damage : Int
  base_armor : Int
  self_damage : Int
  sonic_boom : Int
  pollution_modifier : Int
  exhaust : Bool
  retain : Bool
}

pub enum CardArchetype {
  Basic
  Fortress
  Overload
} derive(Eq)

pub struct CardEfficiency {
  name : String
  ap_cost : Int
  raw_damage : Int
  raw_armor : Int
  self_damage : Int
  sonic_boom_value : Int
  utility_score : Double
  archetype_label : String
  tier : String
}

pub struct CardQuery {
  card_type : String
  archetype : String
  min_cost : Int
  max_cost : Int
  target : String
  keyword : String
  has_special : Bool
  character : String
}

pub enum CardTarget {
  Single
  Self
  Aoe
} derive(Eq)

pub enum CardType {
  Attack
  Skill
  Ability
} derive(Eq)

pub struct Character {
  id : String
  name : String
  name_en : String
  title : String
  title_en : String
  max_hp : Int
  relic : String
  relic_en : String
  relic_effect : String
  lore : String
}

pub struct CharacterComparison {
  aspect : String
  zhong_lv_value : String
  xian_yin_value : String
}

pub struct ChatMessage {
  sender_id : String
  sender_name : String
  content : String
  turn : Int
  is_emote : Bool
}

pub struct Debuff {
  debuff_type : DebuffType
  stacks : Int
}

pub enum DebuffType {
  SonicBoom
  Vulnerable
  Weak
  Poison
  Strength
  Thorn
} derive(Eq)

pub struct DeckConfig {
  name : String
  character_id : String
  card_ids : Array[String]
  max_cards : Int
  min_cards : Int
  description : String
  total_cost : Int
}

pub struct DeckStats {
  total_cards : Int
  total_damage_potential : Int
  total_armor_potential : Int
  average_ap_cost : Double
  attack_ratio : Double
  skill_ratio : Double
  ability_ratio : Double
  s_tier_cards : Int
  a_tier_cards : Int
  b_tier_cards : Int
  c_tier_cards : Int
}

pub struct DifficultyConfig {
  level : AIDifficulty
  label : String
  enemy_hp_mult : Double
  enemy_dmg_bonus : Int
  dice_bias : Int
  pollution_rate_bonus : Int
  player_ap_penalty : Int
}

pub struct Enemy {
  id : String
  name : String
  name_en : String
  lore : String
  hp_1p : Int
  hp_2p : Int
  hp_3p : Int
  hp_4p : Int
  actions : Array[EnemyAction]
  is_boss : Bool
  has_phase2 : Bool
  phase2_actions : Array[EnemyAction]
  phase2_trigger : String
  phase2_effect : String
}

pub struct EnemyAction {
  dice_min : Int
  dice_max : Int
  name : String
  name_en : String
  action_type : EnemyActionType
  effect : String
  damage : Int
  armor : Int
  sonic_boom : Int
  pollution_increase : Int
  piercing : Bool
  special : String
}

pub enum EnemyActionType {
  Attack_
  AttackDebuff
  Buff_
  Aoe_
  Special_
  Summon_
} derive(Eq)

pub struct EnemyState {
  id : String
  name : String
  hp : Int
  max_hp : Int
  armor : Int
  is_boss : Bool
  is_phase2 : Bool
  phase2_triggered : Bool
  summoned_minion : Bool
  reflect_active : Bool
  debuffs : Array[Debuff]
}

pub struct EnemyStrategy {
  enemy_name : String
  threat_level : String
  recommended_approach : String
  dangerous_moves : Array[String]
  tips : Array[String]
}

pub struct Formation {
  name : String
  name_en : String
  formation_type : FormationType
  attack_bonus : Int
  armor_bonus : Int
  sonic_boom_multiplier : Double
  pollution_resistance : Int
  ap_bonus : Int
}

pub enum FormationType {
  Vanguard
  Phalanx
  Assault
  Resonant
  Adaptive
} derive(Eq)

pub enum GameMode {
  QuickBattle
  SurvivalMode
  BossRush
  Training
} derive(Eq)

pub struct HighScore {
  name : String
  score : Int
  wave : Int
  date : String
}

pub struct MatchResult {
  room_id : String
  winner_name : String
  loser_names : Array[String]
  total_turns : Int
  final_pollution : Int
  mvp_player : String
}

pub struct MultiplayerSlot {
  player_id : String
  name : String
  character : Character
  player_state : PlayerState
  is_connected : Bool
  is_ready : Bool
  is_eliminated : Bool
}

pub struct MultiplayerState {
  room_id : String
  players : Array[MultiplayerSlot]
  current_player_index : Int
  turn_number : Int
  pollution : Int
  is_active : Bool
  winner_id : String
  log : Array[String]
}

pub struct NetworkPacket {
  packet_type : String
  room_id : String
  player_id : String
  data : String
  sequence : Int
}

pub struct PlayerAchievement {
  achievement_id : String
  unlocked : Bool
  unlocked_at : String
  progress : Int
  target : Int
}

pub struct PlayerState {
  id : String
  name : String
  hp : Int
  max_hp : Int
  armor : Int
  ap : Int
  max_ap : Int
  hand : Array[Card]
  deck : Array[Card]
  discard : Array[Card]
  exiled : Array[Card]
  permanent_abilities : Array[ActiveAbility]
  damage_bonus : Int
  armor_per_turn : Int
  extra_damage_per_armor : Double
  cards_played_this_turn : Int
  has_taken_self_damage : Bool
  next_attack_bonus : Int
  harmonic_active : Bool
  free_second_attack : Bool
  debuffs : Array[Debuff]
}

pub struct PollutionGuide {
  tier_name : String
  threshold : String
  what_to_do : String
  danger_warning : String
}

pub struct PollutionLevel {
  min_val : Int
  max_val : Int
  name : String
  name_en : String
  damage_bonus : Int
  armor_per_turn : Int
  player_piercing_dmg : Int
}

pub struct Relic {
  id : String
  relic_type : RelicType
  name : String
  name_en : String
  effect : String
  owner_id : String
}

pub enum RelicType {
  OverloadFork
  SnappedString
  AnchorShard
  ResonanceCore
} derive(Eq)

pub struct ReplayFrame {
  frame_id : Int
  action_type : String
  player_hp : Int
  player_armor : Int
  player_ap : Int
  enemy_hp : Int
  enemy_armor : Int
  pollution : Int
  card_id : String
  card_name : String
  enemy_action_name : String
  damage_dealt : Int
  damage_taken : Int
  armor_gained : Int
}

pub struct SimulationResult {
  battles_run : Int
  player_wins : Int
  enemy_wins : Int
  avg_turns : Double
  avg_player_hp : Double
  avg_pollution : Double
  fastest_win : Int
  slowest_win : Int
  total_cards_played : Int
  total_damage_dealt : Int
  total_armor_gained : Int
}

pub struct SpectatorSlot {
  spectator_id : String
  name : String
  joined_at_turn : Int
}

pub struct SurvivalState {
  battle : BattleState
  wave : Int
  score : Int
  enemies_defeated : Int
  is_active : Bool
  difficulty_multiplier : Double
}

pub struct Synergy {
  card_a_id : String
  card_b_id : String
  synergy_type : SynergyType
  description : String
  power_rating : Int
}

pub enum SynergyType {
  DirectCombo
  Conditional
  PassiveBoost
  ArchetypeCore
} derive(Eq)

pub struct TeamConfig {
  leader : Character
  formation : Formation
  difficulty : Int
  enemy_id : String
}

pub struct TrainingSession {
  target_enemy : Enemy
  target_archetype : String
  tips : Array[String]
  practice_attempts : Int
}

fn ability_name(a : ActiveAbility) -> String

fn abyssal_shrieker() -> Enemy

fn achievement_score(achievements : Array[PlayerAchievement]) -> Int

fn adaptive() -> Formation

fn add_card_to_deck(config : DeckConfig, card_id : String) -> DeckConfig

fn add_enemy_armor(state : BattleState, amount : Int) -> BattleState

fn add_log(state : BattleState, msg : String) -> BattleState

fn add_player_armor(state : BattleState, amount : Int) -> BattleState

fn add_sonic_boom(state : BattleState, stacks : Int) -> BattleState

fn add_spectator(spectators : Array[SpectatorSlot], name : String, turn : Int) -> Array[SpectatorSlot]

fn all_achievements() -> Array[Achievement]

fn all_cards() -> Array[Card]

fn all_cards_with_expansion() -> Array[Card]

fn all_characters() -> Array[Character]

fn all_difficulty_labels() -> Array[String]

fn all_enemies() -> Array[Enemy]

fn all_enemies_full() -> Array[Enemy]

fn all_enemy_names() -> Array[String]

fn all_formations() -> Array[Formation]

fn all_game_modes() -> Array[GameMode]

fn all_guides() -> Array[ArchetypeGuide]

fn all_relics() -> Array[Relic]

fn all_strategies() -> Array[EnemyStrategy]

fn all_synergies() -> Array[Synergy]

fn analyze_deck(cards : Array[Card]) -> DeckStats

fn analyze_efficiency(replay : BattleReplay) -> String

fn anchor_shard() -> Relic

fn apply_formation(state : BattleState, formation : Formation) -> BattleState

fn apply_relic_turn_start(state : BattleState, relic : Relic) -> BattleState

fn apply_xian_yin_effect(state : BattleState, card : Card) -> BattleState

fn apply_xian_yin_relic(state : BattleState, cards_played : Int) -> BattleState

fn archetype_menu() -> String

fn assassin_guide() -> ArchetypeGuide

fn assassin_synergies() -> Array[Synergy]

fn assault() -> Formation

fn balance_check(char_id : String, enemy_id : String) -> String

fn battle_summary_to_json(state : BattleState) -> String

fn battle_ui(state : BattleState) -> String

fn benchmark_speed() -> String

fn boss_rush_enemies() -> Array[String]

fn can_start_game(state : MultiplayerState) -> Bool

fn card_statistics() -> String

fn card_to_json(card : Card) -> String

fn cards_to_json(cards : Array[Card]) -> String

fn challenge_achievements() -> Array[Achievement]

fn character_comparisons() -> Array[CharacterComparison]

fn character_select_menu() -> String

fn character_to_json(char : Character) -> String

fn check_achievement_progress(achievements : Array[PlayerAchievement], achievement_id : String, progress : Int, target : Int) -> Array[PlayerAchievement]

fn check_defeat(state : BattleState) -> BattleState

fn check_multiplayer_game_over(state : MultiplayerState) -> Bool

fn check_overload_fork(state : BattleState, card_cost : Int) -> BattleState

fn check_resonance_core(state : BattleState, sonic_boom_stacks : Int) -> BattleState

fn check_snapped_string(state : BattleState, card_type : CardType, cards_played : Int) -> BattleState

fn check_victory(state : BattleState) -> BattleState

fn collection_achievements() -> Array[Achievement]

fn color_blue() -> String

fn color_green() -> String

fn color_purple() -> String

fn color_red() -> String

fn color_reset() -> String

fn color_yellow() -> String

fn combat_achievements() -> Array[Achievement]

fn compare_cards(card_a : Card, card_b : Card) -> String

fn compare_characters(enemy_id : String) -> String

fn compare_decks(deck_a : DeckConfig, deck_b : DeckConfig) -> String

fn count_cards_by_type() -> String

fn count_enemy_actions(replay : BattleReplay) -> Int

fn count_player_cards(replay : BattleReplay) -> Int

fn create_message(sender_id : String, sender_name : String, content : String, turn : Int, is_emote : Bool) -> ChatMessage

fn create_packet(packet_type : String, room_id : String, player_id : String, data : String, seq : Int) -> NetworkPacket

fn create_room(room_id : String, host_name : String, char_id : String) -> MultiplayerState

fn create_team_config(char_id : String, formation_type : FormationType, difficulty : Int, enemy_id : String) -> TeamConfig

fn create_training(archetype : String) -> TrainingSession

fn database_summary() -> String

fn deal_damage_to_enemy(state : BattleState, raw_damage : Int, piercing : Bool) -> BattleState

fn deal_damage_to_player(state : BattleState, damage : Int, piercing : Bool) -> BattleState

fn deck_average_cost(config : DeckConfig) -> Double

fn deck_cost_distribution(config : DeckConfig) -> String

fn deck_statistics(config : DeckConfig) -> String