import { BgsPlayerEntity, BgsQuestEntity, BoardTrinket } from '../bgs-player-entity';
import { BoardEnchantment, BoardEntity } from '../board-entity';
import { BoardSecret } from '../board-secret';
import { OnDivineShieldUpdatedInput } from '../keywords/divine-shield';
import { OnRebornUpdatedInput } from '../keywords/reborn';
import { OnStealthUpdatedInput } from '../keywords/stealth';
import { OnTauntUpdatedInput } from '../keywords/taunt';
import { OnVenomousUpdatedInput } from '../keywords/venomous';
import { OnWindfuryUpdatedInput } from '../keywords/windfury';
import { OnDespawnInput, OnOtherSpawnAuraInput, OnOtherSpawnInput, OnSpawnInput } from '../simulation/add-minion-to-board';
import { OnAfterDeathInput, OnDeathInput, OnMinionKilledInput } from '../simulation/attack';
import { AvengeInput } from '../simulation/avenge';
import { BattlecryInput, OnBattlecryTriggeredInput } from '../simulation/battlecries';
import { PlayedBloodGemsOnAnyInput, PlayedBloodGemsOnMeInput } from '../simulation/blood-gems';
import { OnCardAddedToHandInput } from '../simulation/cards-in-hand';
import { AfterDealDamageInput } from '../simulation/damage-effects';
import { AfterHeroDamagedInput } from '../simulation/damage-to-hero';
import { DeathrattleTriggeredInput } from '../simulation/deathrattle-on-trigger';
import { FullGameState } from '../simulation/internal-game-state';
import { OnAfterMagnetizeInput, OnBeforeMagnetizeInput, OnBeforeMagnetizeSelfInput } from '../simulation/magnetize';
import { OnAttackInput } from '../simulation/on-attack';
import { OnMinionAttackedInput } from '../simulation/on-being-attacked';
import { RebornEffectInput } from '../simulation/reborn';
import { SoCInput } from '../simulation/start-of-combat/start-of-combat-input';
import { OnStatsChangedInput } from '../simulation/stats';
export interface Card {
    cardIds?: readonly string[];
    startOfCombat?: (trinket: BoardEntity | BoardTrinket | BgsPlayerEntity | BoardSecret, input: SoCInput) => boolean | {
        hasTriggered: boolean;
        shouldRecomputeCurrentAttacker: boolean;
    };
}
export interface DefaultChargesCard extends Card {
    defaultCharges: (entity: BoardEntity) => number;
}
export declare const hasDefaultCharges: (card: Card) => card is DefaultChargesCard;
export interface StartOfCombatCard extends Card {
    startOfCombatTiming?: StartOfCombatTiming;
    startOfCombat: NonNullable<Card['startOfCombat']>;
}
export declare const hasStartOfCombat: (card: Card) => card is StartOfCombatCard;
export interface StartOfCombatFromHandCard extends StartOfCombatCard {
    startOfCombatFromHand: true;
}
export declare const hasStartOfCombatFromHand: (card: Card) => card is StartOfCombatFromHandCard;
export type StartOfCombatTiming = 'start-of-combat' | 'pre-combat' | 'illidan';
export interface TavernSpellCard extends Card {
    castTavernSpell: (spellCardId: string, input: CastSpellInput) => void;
}
export declare const hasCastTavernSpell: (card: Card) => card is TavernSpellCard;
export interface OnTavernSpellCastCard extends Card {
    onTavernSpellCast: (entity: BoardEntity | BoardTrinket, input: CastSpellInput) => void;
}
export declare const hasOnTavernSpellCast: (card: Card) => card is OnTavernSpellCastCard;
export interface AfterTavernSpellCastCard extends Card {
    afterTavernSpellCast: (entity: BoardEntity | BoardTrinket, input: CastSpellInput) => void;
}
export declare const hasAfterTavernSpellCast: (card: Card) => card is AfterTavernSpellCastCard;
export interface RallyCard extends Card {
    rally: (minion: BoardEntity | BoardTrinket | BoardEnchantment, input: OnAttackInput) => {
        dmgDoneByAttacker: number;
        dmgDoneByDefender: number;
    };
}
export declare const hasRally: (card: Card) => card is RallyCard;
export interface OnWheneverAnotherMinionAttacksCard extends Card {
    onWheneverAnotherMinionAttacks: (minion: BoardEntity | BoardTrinket | BoardEnchantment, input: OnAttackInput) => {
        dmgDoneByAttacker: number;
        dmgDoneByDefender: number;
    };
}
export declare const hasOnWheneverAnotherMinionAttacks: (card: Card) => card is OnWheneverAnotherMinionAttacksCard;
export interface OnMinionAttackedCard extends Card {
    onAttacked: (minion: BoardEntity, input: OnMinionAttackedInput) => void;
}
export declare const hasOnMinionAttacked: (card: Card) => card is OnMinionAttackedCard;
export interface OnSpawnedCard extends Card {
    onSpawned: (minion: BoardEntity, input: OnSpawnInput) => void;
}
export declare const hasOnSpawned: (card: Card) => card is OnSpawnedCard;
export interface OnOtherSpawnedAuraCard extends Card {
    onOtherSpawnedAura: (minion: BoardEntity, input: OnOtherSpawnAuraInput) => void;
}
export declare const hasOnOtherAuraSpawned: (card: Card) => card is OnOtherSpawnedAuraCard;
export interface OnOtherSpawnedCard extends Card {
    onOtherSpawned: (minion: BoardEntity, input: OnOtherSpawnInput) => void;
}
export declare const hasOnOtherSpawned: (card: Card) => card is OnOtherSpawnedCard;
export interface AfterOtherSpawnedCard extends Card {
    afterOtherSpawned: (minion: BoardEntity | BoardTrinket, input: OnOtherSpawnInput) => void;
}
export declare const hasAfterOtherSpawned: (card: Card) => card is AfterOtherSpawnedCard;
export interface OnDespawnedCard extends Card {
    onDespawned: (minion: BoardEntity, input: OnDespawnInput) => void;
}
export declare const hasOnDespawned: (card: Card) => card is OnDespawnedCard;
export interface DeathrattleSpawnCard extends Card {
    deathrattleSpawn: (minion: BoardEntity, input: DeathrattleTriggeredInput) => readonly BoardEntity[];
}
export declare const hasDeathrattleSpawn: (card: Card) => card is DeathrattleSpawnCard;
export interface BattlecryCard extends Card {
    battlecry: (minion: BoardEntity, input: BattlecryInput) => boolean;
}
export declare const hasBattlecry: (card: Card) => card is BattlecryCard;
export interface RebornEffectCard extends Card {
    rebornEffect: (minion: BoardEntity, input: RebornEffectInput) => void;
}
export declare const hasRebornEffect: (card: Card) => card is RebornEffectCard;
export interface RebornSelfEffectCard extends Card {
    rebornSelfEffect: (minion: BoardEntity, input: RebornEffectInput) => void;
}
export declare const hasRebornSelfEffect: (card: Card) => card is RebornSelfEffectCard;
export interface OnBattlecryTriggeredCard extends Card {
    onBattlecryTriggered: (minion: BoardEntity, input: OnBattlecryTriggeredInput) => void;
}
export declare const hasOnBattlecryTriggered: (card: Card) => card is OnBattlecryTriggeredCard;
export interface AvengeCard extends Card {
    avenge: (minion: BoardEntity | BoardTrinket, input: AvengeInput) => void | readonly BoardEntity[];
    baseAvengeValue: (cardId: string) => number;
}
export declare const hasAvenge: (card: Card) => card is AvengeCard;
export interface DefaultScriptDataNumCard extends Card {
    defaultScriptDataNum: (cardId: string) => number;
}
export declare const hasDefaultScriptDataNum: (card: Card) => card is DefaultScriptDataNumCard;
export interface DeathrattleTriggeredCard extends Card {
    onDeathrattleTriggered: (minion: BoardEntity | BoardTrinket, input: DeathrattleTriggeredInput) => void;
}
export declare const hasOnDeathrattleTriggered: (card: Card) => card is DeathrattleTriggeredCard;
export interface DeathrattleSpawnEnchantmentCard extends Card {
    deathrattleSpawnEnchantmentEffect: (enchantment: {
        cardId: string;
        originEntityId?: number;
        repeats?: number;
    }, minion: BoardEntity | null | undefined, input: DeathrattleTriggeredInput) => readonly BoardEntity[];
    cardIds: readonly string[];
}
export declare const hasDeathrattleSpawnEnchantment: (card: Card) => card is DeathrattleSpawnEnchantmentCard;
export interface OnCardAddedToHandCard extends Card {
    onCardAddedToHand: (entity: BoardEntity | BgsQuestEntity, input: OnCardAddedToHandInput) => void;
}
export declare const hasOnCardAddedToHand: (card: Card) => card is OnCardAddedToHandCard;
export interface EndOfTurnCard extends Card {
    endOfTurn: (entity: BoardEntity, input: EndOfTurnInput) => void;
}
export declare const hasEndOfTurn: (card: Card) => card is EndOfTurnCard;
export type EndOfTurnInput = BattlecryInput;
export interface OnDivineShieldUpdatedCard extends Card {
    onDivineShieldUpdated: (entity: BoardEntity | BoardTrinket, input: OnDivineShieldUpdatedInput) => void;
}
export declare const hasOnDivineShieldUpdated: (card: Card) => card is OnDivineShieldUpdatedCard;
export interface OnTauntUpdatedCard extends Card {
    onTauntUpdated: (entity: BoardEntity, impactedEntity: BoardEntity, previousValue: boolean, input: OnTauntUpdatedInput) => void;
}
export declare const hasOnTauntUpdated: (card: Card) => card is OnTauntUpdatedCard;
export interface OnRebornUpdatedCard extends Card {
    onRebornUpdated: (entity: BoardEntity, impactedEntity: BoardEntity, previousValue: boolean, input: OnRebornUpdatedInput) => void;
}
export declare const hasOnRebornUpdated: (card: Card) => card is OnRebornUpdatedCard;
export interface OnStealthUpdatedCard extends Card {
    onStealthUpdated: (entity: BoardEntity, impactedEntity: BoardEntity, previousValue: boolean, input: OnStealthUpdatedInput) => void;
}
export declare const hasOnStealthUpdated: (card: Card) => card is OnStealthUpdatedCard;
export interface OnVenomousUpdatedCard extends Card {
    onVenomousUpdated: (entity: BoardEntity, impactedEntity: BoardEntity, previousValue: boolean, input: OnVenomousUpdatedInput) => void;
}
export declare const hasOnVenomousUpdated: (card: Card) => card is OnVenomousUpdatedCard;
export interface OnWindfuryUpdatedCard extends Card {
    onWindfuryUpdated: (entity: BoardEntity, impactedEntity: BoardEntity, previousValue: boolean, input: OnWindfuryUpdatedInput) => void;
}
export declare const hasOnWindfuryUpdated: (card: Card) => card is OnWindfuryUpdatedCard;
export interface OnStatsChangedCard extends Card {
    onStatsChanged: (entity: BoardEntity, input: OnStatsChangedInput) => void;
}
export declare const hasOnStatsChanged: (card: Card) => card is OnStatsChangedCard;
export interface AfterHeroDamagedCard extends Card {
    afterHeroDamaged: (entity: BoardEntity, input: AfterHeroDamagedInput) => void;
}
export declare const hasAfterHeroDamaged: (card: Card) => card is AfterHeroDamagedCard;
export interface OnDamagedCard extends Card {
    onDamaged: (entity: BoardEntity, input: OnDamagedInput) => void;
}
export declare const hasOnDamaged: (card: Card) => card is OnDamagedCard;
export interface AfterDealDamageCard extends Card {
    afterDealDamage: (entity: BoardEntity, input: AfterDealDamageInput) => void;
}
export declare const hasAfterDealDamage: (card: Card) => card is AfterDealDamageCard;
export interface OnDeathCard extends Card {
    onDeath: (entity: BoardEntity, input: OnDeathInput) => void;
}
export declare const hasOnDeath: (card: Card) => card is OnDeathCard;
export interface OnAfterDeathCard extends Card {
    onAfterDeath: (entity: BoardEntity | BoardTrinket, input: OnAfterDeathInput) => void;
}
export declare const hasOnAfterDeath: (card: Card) => card is OnAfterDeathCard;
export interface OnMinionKilledCard extends Card {
    onMinionKilled: (entity: BoardEntity, input: OnMinionKilledInput) => {
        dmgDoneByAttacker: number;
        dmgDoneByDefender: number;
    };
}
export declare const hasOnMinionKilled: (card: Card) => card is OnMinionKilledCard;
export interface OnBeforeMagnetizeCard extends Card {
    onBeforeMagnetize: (entity: BoardEntity, input: OnBeforeMagnetizeInput) => void;
}
export declare const hasOnBeforeMagnetize: (card: Card) => card is OnBeforeMagnetizeCard;
export interface OnBeforeMagnetizeSelfCard extends Card {
    onBeforeMagnetizeSelf: (entity: BoardEntity, input: OnBeforeMagnetizeSelfInput) => void;
}
export declare const hasOnBeforeMagnetizeSelf: (card: Card) => card is OnBeforeMagnetizeSelfCard;
export interface OnAfterMagnetizeCard extends Card {
    onAfterMagnetize: (entity: BoardEntity, input: OnAfterMagnetizeInput) => void;
}
export declare const hasOnAfterMagnetize: (card: Card) => card is OnAfterMagnetizeCard;
export interface OnSpawnFailCard extends Card {
    onSpawnFail: (entity: BoardEntity, input: OnSpawnFailInput) => void;
}
export declare const hasOnSpawnFail: (card: Card) => card is OnSpawnFailCard;
export interface PlayedBloodGemsOnMeCard extends Card {
    playedBloodGemsOnMe: (entity: BoardEntity, input: PlayedBloodGemsOnMeInput) => void;
}
export declare const hasPlayedBloodGemsOnMe: (card: Card) => card is PlayedBloodGemsOnMeCard;
export interface PlayedBloodGemsOnAnyCard extends Card {
    playedBloodGemsOnAny: (entity: BoardEntity, input: PlayedBloodGemsOnAnyInput) => void;
}
export declare const hasPlayedBloodGemsOnAny: (card: Card) => card is PlayedBloodGemsOnAnyCard;
export interface OnSpawnFailInput {
    failedSpawn: BoardEntity;
    board: BoardEntity[];
    hero: BgsPlayerEntity;
    gameState: FullGameState;
}
export interface CastSpellInput {
    spellCardId: string;
    source: BoardEntity | BoardTrinket | BgsPlayerEntity;
    target: BoardEntity;
    board: BoardEntity[];
    hero: BgsPlayerEntity;
    otherBoard: BoardEntity[];
    otherHero: BgsPlayerEntity;
    gameState: FullGameState;
}
export interface OnDamagedInput {
    damagedEntity: BoardEntity;
    damageDealer: BoardEntity | BgsPlayerEntity;
    damage: number;
    board: BoardEntity[];
    hero: BgsPlayerEntity;
    gameState: FullGameState;
}
