import type { Character } from '../Character/types';
import type { Enemy } from '../Enemy/types';
import type { Effect, ActiveEffect } from '../Effects/types';
import type { CombatResources } from '../Cards/types';
import type { Stance } from './types';
export type CombatDieColor = 'heart' | 'body' | 'mind' | 'wild' | 'x';
export type CombatDieState = 'available' | 'spent' | 'exhausted' | 'preserved' | 'locked';
export interface CombatManaDie {
    id: string;
    color: CombatDieColor;
    state: CombatDieState;
    temporary: boolean;
}
export type CombatVerbClass = 'direct-dot' | 'direct-control' | 'stat-debuff' | 'buff-self' | 'direct-damage' | 'befriend' | 'defend' | 'retreat';
export type CardEffectKind = 'dot' | 'control' | 'none';
export interface CombatCard {
    id: string;
    skillId: string | null;
    name: string;
    stance: CombatDieColor;
    verbClass: CombatVerbClass;
    effectKind: CardEffectKind;
    tier: 1 | 2 | 3;
    rarity?: 'gold';
    category: 'fallacy' | 'paradox' | null;
    topActionText: string;
    bottomActionText: string;
    bottomDamagePreview: number;
    primaryEffectId: string | null;
}
export interface CombatHandEntry {
    uid: string;
    cardId: string;
}
export interface CardPlay {
    uid?: string;
    cardId: string;
    useBottom: boolean;
    dieId?: string;
}
export type CombatReadResult = 'advantage' | 'neutral' | 'disadvantage' | 'none';
export type SignatureSkillKind = 'scout' | 'reroll' | 'sustain' | 'control' | 'dot' | 'mercy' | 'strike' | 'conclude' | 'draw';
export type SignatureSkillId = 'sig-read-opponent' | 'sig-press-the-point' | 'sig-second-wind' | 'sig-overwhelming-argument' | 'sig-conviction-strike' | 'sig-disarming-plea' | 'sig-rallying-blow' | 'sig-clever-gambit';
export type PlayerArchetype = 'heart' | 'body' | 'mind';
export interface SignatureSkill {
    id: SignatureSkillId;
    name: string;
    description: string;
    cost: number;
    kind: SignatureSkillKind;
    effectKind?: CardEffectKind;
    effectId?: string;
    magnitude: number;
}
export interface CombatThreatEffect {
    damage?: number;
    effectId?: string;
    intensity?: number;
    duration?: number;
    enemyHeal?: number;
}
export interface CombatThreatAction {
    description: string;
    effects: CombatThreatEffect[];
}
export type CombatIntentType = 'damage' | 'debuff' | 'buff' | 'block' | 'pass' | 'combo';
export interface CombatThreatPhase {
    index: number;
    enemyStance: Stance;
    threatAction: CombatThreatAction;
    isFinalPhase: boolean;
    intentType?: CombatIntentType;
    intentLabel?: string;
    stanceHint?: string;
}
export type CombatThreatMark = 'clear' | 'overwhelmed' | 'pending';
export interface CombatPhaseResult {
    phaseIndex: number;
    mark: 'clear' | 'overwhelmed';
    enemyActionFired: string;
    penaltiesApplied: CombatThreatEffect[];
}
export interface CombatAttributionRow {
    cardId: string;
    name: string;
    dotDamage: number;
    damageDealt: number;
    phases: number;
}
export interface CombatSummary {
    outcome: CombatOutcome;
    headline: string;
    rows: CombatAttributionRow[];
    totalDotDamage: number;
    directDamage: number;
    bestCard: string;
}
export type CombatOutcome = 'victory' | 'mercy' | 'defeat' | 'retreat';
export type CombatEncounterPhase = 'reveal' | 'dice-roll' | 'phase-play' | 'phase-resolve' | 'between-phases' | 'mercy-choice' | 'complete';
export type CombatEvent = {
    kind: 'dice-rolled';
    dice: CombatManaDie[];
} | {
    kind: 'turn-dice-rolled';
    turn: number;
    dice: CombatManaDie[];
} | {
    kind: 'die-drafted';
    dieId: string;
    color: CombatDieColor;
    read: CombatReadResult;
} | {
    kind: 'conviction-gained';
    amount: number;
    total: number;
    reason: 'unpicked-die' | 'read-win' | 'effect';
} | {
    kind: 'stance-revealed';
    phaseIndex: number;
    stance: Stance;
} | {
    kind: 'read-result';
    stance: CombatDieColor;
    enemyStance: Stance;
    result: CombatReadResult;
} | {
    kind: 'signature-cast';
    skillId: SignatureSkillId;
    name: string;
    cost: number;
} | {
    kind: 'card-played';
    cardId: string;
    useBottom: boolean;
    dieId: string | null;
    advantage: 'advantage' | 'neutral' | 'disadvantage';
    colorMatch?: boolean;
} | {
    kind: 'effect-landed';
    cardId: string;
    effectId: string;
    target: 'self' | 'enemy';
    effectKind: CardEffectKind;
    intensity: number;
    effect: Effect;
} | {
    kind: 'effect-fizzled';
    cardId: string;
    effectId: string;
    message: string;
} | {
    kind: 'buff-stripped';
    cardId: string;
    target: 'self' | 'enemy';
    effectId: string | null;
    effectName: string | null;
} | {
    kind: 'damage-dealt';
    cardId: string;
    target: 'self' | 'enemy';
    amount: number;
} | {
    kind: 'die-refreshed';
    dieId: string;
    color: CombatDieColor;
} | {
    kind: 'die-spent';
    dieId: string;
    color: CombatDieColor;
} | {
    kind: 'dot-tick';
    effectId: string;
    label: string;
    amount: number;
    target: 'self' | 'enemy';
} | {
    kind: 'rupture-detonated';
    amount: number;
    consumed: string[];
} | {
    kind: 'amplify-detonated';
    amount: number;
    pendingDot: number;
} | {
    kind: 'compound-hit';
    amount: number;
    debuffs: number;
} | {
    kind: 'disrupt-denied';
    pips: number;
} | {
    kind: 'thorns-reflected';
    amount: number;
    target: 'enemy';
} | {
    kind: 'barrier-absorbed';
    amount: number;
} | {
    kind: 'riposte-fired';
    amount: number;
} | {
    kind: 'execute-fired';
    amount: number;
    recoil: number;
} | {
    kind: 'conclude-hit';
    amount: number;
    totalStacks: number;
} | {
    kind: 'phase-resolved';
    phaseIndex: number;
    mark: 'clear' | 'overwhelmed';
} | {
    kind: 'threat-fired';
    phaseIndex: number;
    description: string;
    effects: CombatThreatEffect[];
} | {
    kind: 'hand-drawn';
    cards: string[];
} | {
    kind: 'mercy-opened';
    message: string;
} | {
    kind: 'combat-ended';
    outcome: CombatOutcome;
};
export interface CombatEncounterState {
    phase: CombatEncounterPhase;
    enemy: Enemy;
    player: Character;
    dice: CombatManaDie[];
    draftedDieId: string | null;
    turn: number;
    conviction: number;
    guard?: number;
    barrier?: number;
    riposte?: {
        damage: number;
        reduce: number;
    };
    revealedStances: number[];
    lastRead: CombatReadResult;
    chainEffectIds?: string[];
    carriedDie: CombatDieColor | null;
    archetype: PlayerArchetype;
    signatures: SignatureSkillId[];
    deck: string[];
    drawPile: string[];
    discard: string[];
    hand: CombatHandEntry[];
    persistentZone: string[];
    threatPhases: CombatThreatPhase[];
    threatMarks: CombatThreatMark[];
    currentPhaseIndex: number;
    phaseResults: CombatPhaseResult[];
    combatResources: CombatResources;
    round: number;
    attribution: Record<string, CombatAttributionRow>;
    directDamageDealt: number;
    log: CombatEvent[];
    finalOutcome: CombatOutcome | null;
    mercyChoiceActive?: boolean;
    seed?: number;
}
export interface CombatTransition {
    state: CombatEncounterState;
    events: CombatEvent[];
}
export interface LandedEffect {
    effectId: string;
    effect: Effect;
    active: ActiveEffect;
    target: 'self' | 'enemy';
}
//# sourceMappingURL=combat.encounter.types.d.ts.map