/** One discrete pick move: how far the pick drives into the lock this step. */
export type LockAction = "hardSet" | "set" | "steady" | "ease" | "drop";
/** Vertical row delta applied to the pick for each action. Row 0 is the shallow/top row. */
export declare const LOCK_ACTION_DELTA: Readonly<Record<LockAction, number>>;
/** The five pick actions, in display order (shallow → deep). */
export declare const LOCK_ACTIONS: readonly LockAction[];
/** Difficulty dials for one lock: board size, forgiveness band, gates, fog window, traps. */
export interface LockTierSpec {
    cols: number;
    rows: number;
    width: number;
    gateCount: number;
    visibilityWindow: number;
    allowedActions: readonly LockAction[];
    trapCount?: number;
}
/** A generated lock board. `open[col]` holds every enterable row in that column. */
export interface LockSpec {
    seed: string | number;
    tier: LockTierSpec;
    open: readonly (readonly number[])[];
    gates: readonly number[];
    traps: readonly (readonly number[])[];
    startRow: number;
    seatRow: number;
}
/** Outcome of one {@link stepLock} call: `advanced`/`success` move the pick, `slip`/`bind`/`trap`
 * do not and should cost a life. */
export type LockStepResult = "advanced" | "slip" | "bind" | "trap" | "success";
/** What a revealed cell renders as: a plain open notch, an exact tumbler gate, the bolt seat
 * (win condition), or a ward-trap that looks open but jams on contact. */
export type LockCellKind = "open" | "gate" | "seat" | "trap";
/** One cell inside the fogged {@link visibleCells} window: its board position and kind. */
export interface LockCell {
    col: number;
    row: number;
    kind: LockCellKind;
}
/**
 * Generate a solvable depth-puzzle lock: a "Tumbler's Path" board with a guaranteed solution
 * path carved first, an open-row forgiveness band wrapped around it, tumbler gate columns that
 * pinch to a single exact row, and optional ward-traps that look open but jam on contact.
 * Deterministic: the same (seed, tier) always yields the same board.
 *
 * @capability lockpick a solvable grid depth-puzzle with fog-of-war, gates, and hidden traps
 */
export declare function generateLock(seed: string | number, tier: LockTierSpec): LockSpec;
/** Return a concrete row-per-column solution, or null if the board is unsolvable. */
export declare function solveLockPath(spec: LockSpec): number[] | null;
/** Whether the board has a path from the start row to the bolt seat at all. */
export declare function solveLock(spec: LockSpec): boolean;
/** Authoritative single step. The caller owns the lives economy: a slip/bind/trap does not
 * advance the pick and should cost a life; advanced/success move the pick. */
export declare function stepLock(spec: LockSpec, col: number, row: number, action: LockAction): {
    result: LockStepResult;
    col: number;
    row: number;
};
/** The render-safe slice: every open cell in columns [0, col + window]. The single source of
 * truth for fog and the anti-cheat boundary — never serialize the full spec to a client. */
export declare function visibleCells(spec: LockSpec, col: number, window: number): LockCell[];