export type Side = string;
export interface LaneRuleInput<C> {
    lane: number;
    side: Side;
    cards: readonly C[];
    subtotal: number;
}
export interface LaneRule<C> {
    id: string;
    apply: (input: LaneRuleInput<C>) => number;
}
export interface LaneBoardConfig<C> {
    laneCount: number;
    sides: readonly Side[];
    power: (card: C) => number;
    laneRules?: readonly (LaneRule<C> | null | undefined)[];
}
export interface LaneCells<C> {
    readonly [side: Side]: readonly C[];
}
export interface LaneBoardState<C> {
    readonly lanes: readonly LaneCells<C>[];
}
export interface LaneAggregate {
    lane: number;
    side: Side;
    subtotal: number;
    total: number;
    count: number;
}
export interface LaneOutcome {
    lane: number;
    totals: Readonly<Record<Side, number>>;
    winner: Side | null;
}
export type LaneRejection = "invalid-lane" | "invalid-side";
export interface LanePlaceResult<C> {
    status: "ok";
    state: LaneBoardState<C>;
}
export interface LanePlaceRejected {
    status: "rejected";
    reason: LaneRejection;
}
export type LaneResult<C> = LanePlaceResult<C> | LanePlaceRejected;
/** @internal */
export declare function createLaneBoardState<C>(config: LaneBoardConfig<C>): LaneBoardState<C>;
/** @internal */
export declare function placeCard<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>, lane: number, side: Side, card: C): LaneResult<C>;
/** @internal */
export declare function removeCard<C>(state: LaneBoardState<C>, lane: number, side: Side, predicate: (card: C, index: number) => boolean): LaneResult<C>;
/** @internal */
export declare function laneAggregate<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>, lane: number, side: Side): LaneAggregate;
/** @internal */
export declare function laneOutcome<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>, lane: number): LaneOutcome;
/** @internal */
export declare function boardTotals<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>): Readonly<Record<Side, number>>;
/** @internal */
export declare function lanesWon<C>(state: LaneBoardState<C>, config: LaneBoardConfig<C>): Readonly<Record<Side, number>>;
export interface LaneBoard<C> {
    state(): LaneBoardState<C>;
    place(lane: number, side: Side, card: C): LaneResult<C>;
    remove(lane: number, side: Side, predicate: (card: C, index: number) => boolean): LaneResult<C>;
    aggregate(lane: number, side: Side): LaneAggregate;
    outcome(lane: number): LaneOutcome;
    totals(): Readonly<Record<Side, number>>;
    lanesWon(): Readonly<Record<Side, number>>;
    reset(next?: LaneBoardState<C>): void;
}
/**
 * A lane-based board where cards resolve per lane — the lane card-battler layout.
 *
 * @capability lane-board a lane-based card-battler board with per-lane outcomes
  * @internal
  */
export declare function createLaneBoard<C>(config: LaneBoardConfig<C>): LaneBoard<C>;