/**
 * HeadlessGame - Runs game simulation without WebSocket
 *
 * Main class for testing full player lifecycles. Uses GameEngine
 * with OutputCollector for capturing events and AutoResponder for
 * automatic question answering.
 */
import type { Player } from '../models/index.js';
import { OutputCollector, type CollectedEvent, type CollectedQuestion } from './OutputCollector.js';
import { type ResponseStrategy, type ResponseLogEntry } from './AutoResponder.js';
import { type LifeStage, type PlayerFactoryOptions } from './PlayerFactory.js';
import { type RomanceSimulatorOptions, type RomanceLogEntry } from './RomanceSimulator.js';
export interface HeadlessGameOptions {
    autoRespond?: boolean;
    responseStrategy?: ResponseStrategy;
    logResponses?: boolean;
    maxTicksPerAdvance?: number;
    player?: Player;
    playerOptions?: PlayerFactoryOptions;
    startAge?: number;
    startStage?: LifeStage;
    /** Enable romance simulation (default: true) */
    simulateRomance?: boolean;
    /** Romance simulator options */
    romanceOptions?: RomanceSimulatorOptions;
    /** Enable happiness recovery (default: true) - slowly restores happiness toward baseline */
    enableHappinessRecovery?: boolean;
    /** Target happiness baseline for recovery (default: 50) */
    happinessBaseline?: number;
}
export interface GameSummary {
    playerId: string;
    playerName: string;
    status: string;
    startAge: number;
    endAge: number;
    totalDays: number;
    totalTicks: number;
    eventsCount: number;
    questionsCount: number;
    questionsAnswered: number;
    hasPartner: boolean;
    relationshipStatus?: string;
    romanceEventsCount: number;
    causeOfDeath?: string;
}
/**
 * HeadlessGame runs a game simulation without WebSocket
 */
export declare class HeadlessGame {
    readonly player: Player;
    readonly output: OutputCollector;
    private engine;
    private autoResponder;
    private romanceSimulator;
    private autoRespond;
    private simulateRomance;
    private enableHappinessRecovery;
    private happinessBaseline;
    private maxTicksPerAdvance;
    private startAge;
    private lastRomanceCheckAge;
    private lastHappinessRecoveryDay;
    constructor(options?: HeadlessGameOptions);
    /**
     * Run N game ticks
     */
    tick(count?: number): Promise<void>;
    /**
     * Parse all registered events and trigger any that match conditions
     */
    private parseEvents;
    /**
     * Process any pending questions with auto-responder
     */
    private processPendingQuestions;
    /**
     * Apply weekly happiness recovery toward baseline
     * Models psychological adaptation - people naturally adapt to circumstances
     * Recovery rate: ~2-5 points per week toward baseline
     */
    private applyHappinessRecovery;
    /**
     * Advance game time by N minutes
     */
    advanceMinutes(minutes: number): Promise<void>;
    /**
     * Advance game time by N hours
     */
    advanceHours(hours: number): Promise<void>;
    /**
     * Advance game time by N days
     */
    advanceDays(days: number): Promise<void>;
    /**
     * Advance game time by N years
     */
    advanceYears(years: number): Promise<void>;
    /**
     * Advance until player reaches target age
     */
    advanceToAge(targetAge: number): Promise<void>;
    /**
     * Advance until player dies or reaches maximum age
     */
    advanceToEnd(maxAge?: number): Promise<void>;
    /**
     * Get all collected events
     */
    getEvents(): CollectedEvent[];
    /**
     * Get all collected questions
     */
    getQuestions(): CollectedQuestion[];
    /**
     * Get response log from auto-responder
     */
    getResponseLog(): ResponseLogEntry[];
    /**
     * Get romance event log
     */
    getRomanceLog(): RomanceLogEntry[];
    /**
     * Get game statistics
     */
    getStats(): Record<string, number>;
    /**
     * Get game summary
     */
    getSummary(): GameSummary;
    /**
     * Print summary to console
     */
    printSummary(): void;
    /**
     * Check if player has an event with specific ID
     * Checks both output collector and player's internal event/question tracking
     */
    hasEvent(eventId: string): boolean;
    /**
     * Check if player has an event containing specific text
     */
    hasEventWithText(text: string): boolean;
    /**
     * Clear all collected output
     */
    clearOutput(): void;
}
//# sourceMappingURL=HeadlessGame.d.ts.map