/**
 * Base Event Classes and Helper Functions
 * Ported from Python events/base.py
 *
 * Contains:
 * - Event class definitions (QuestionEvent, MessageEvent, TimeEvent, DilemmaClass, AnswerOption)
 * - Helper functions (createMessageEvent, createQuestionEvent)
 */
import type { Player } from '../models/Player.js';
/**
 * Event mode determines when an event can fire based on game speed.
 * - 'realtime': Only fires at slow speeds (gameSpeed >= 1000)
 * - 'fast': Only fires at fast speeds (gameSpeed < 1000)
 * - 'both': Fires at any speed (default)
 */
export type EventMode = 'realtime' | 'fast' | 'both';
/** Speed threshold: gameSpeed >= this value is considered "realtime" */
export declare const REALTIME_SPEED_THRESHOLD = 1000;
/**
 * Check if an event should be skipped based on its mode and current game speed.
 * Returns true if the event should NOT fire.
 */
export declare function shouldSkipForMode(mode: EventMode | undefined, gameSpeed: number): boolean;
/**
 * Simplified character data for event payloads
 */
export interface SimpleCharacter {
    id: string;
    firstname: string;
    lastname: string;
    image: string;
}
/**
 * Answer option for question events
 * All fields except 'option' are optional for convenience
 */
export interface AnswerOption {
    option: string;
    data?: string;
    id?: string;
    energyCost?: number;
    diamondCost?: number;
    moneyCost?: number;
}
/**
 * Event configuration for class-based events
 */
export interface EventConfig {
    minAge: number;
    maxAge: number;
    baseChance: number;
    triggerType: 'random' | 'scheduled' | 'conditional';
}
/**
 * Base class for all game events
 * Provides common structure for activity, tutorial, and dilemma events
 */
export declare abstract class BaseEvent {
    abstract readonly id: string;
    /**
     * Event mode: controls when this event can fire based on game speed.
     * Override in subclasses to restrict to 'realtime' or 'fast'.
     */
    get mode(): EventMode;
    /**
     * Get event configuration (age range, trigger type, probability)
     */
    abstract getConfig(): EventConfig;
    /**
     * Check if event conditions are met for the player
     */
    abstract checkConditions(player: Player): boolean;
    /**
     * Get the question text to display
     */
    abstract getQuestion(player?: Player): string;
    /**
     * Get available answer options
     */
    abstract getAnswerOptions(): AnswerOption[];
    /**
     * Process the player's answer and return the result
     */
    abstract processAnswer(player: Player, selectedOption: number): EventResult;
    /**
     * Check if this event should trigger based on probability
     */
    shouldTrigger(): boolean;
    /**
     * Check if player is within age range for this event
     */
    isAgeValid(player: Player): boolean;
}
/**
 * Create an answer option
 */
export declare function createAnswerOption(option: string, data?: string, energyCost?: number, diamondCost?: number, moneyCost?: number): AnswerOption;
/**
 * Question event requiring player choice
 * @deprecated Active runtime uses `events/v2` envelopes.
 */
export interface QuestionEvent {
    id: string;
    type: 'questionEvent';
    message: string;
    objectId?: string;
    answers: AnswerOption[];
    characters: SimpleCharacter[];
    image: string;
}
/**
 * Message event (notification)
 */
export interface MessageEventData {
    id: string;
    type: 'messageEvent';
    date: string;
    hour: number;
    message: string;
    title: string;
    image: string;
    energyCost: number;
    diamondCost: number;
    moneyCost: number;
    affinityChange: number;
    characters: SimpleCharacter[];
}
/**
 * Time-based event
 */
export interface TimeEvent {
    type: 'timeEvent';
}
/**
 * Dilemma with multiple steps
 * @deprecated Legacy v1 dilemma shape retained for compatibility modules only.
 */
export interface DilemmaClass {
    type: 'dilemma';
    function: string;
    answer: AnswerOption | null;
    answerOptions: AnswerOption[];
    step: number;
}
/**
 * Create a dilemma
 * @deprecated Legacy v1 helper retained for compatibility modules only.
 */
export declare function createDilemma(fname: string, answerOptions: AnswerOption[]): DilemmaClass;
/**
 * Character interface for serialization
 */
interface CharacterLike {
    id: string;
    firstname: string;
    lastname: string;
    image: string;
}
/**
 * Create a message event
 * Ported from Python messageFunction
 */
export declare function createMessageEvent(fname: string, message: string, player: Player, check: boolean, options?: {
    title?: string;
    image?: string;
    energyCost?: number;
    diamondCost?: number;
    moneyCost?: number;
    affinityChange?: number;
    characters?: CharacterLike[];
}): MessageEventData | null;
/**
 * Create a question event
 * Ported from Python questionFunction
 */
export declare function createQuestionEvent(fname: string, message: string | {
    message: string;
    id: string;
}, player: Player, check: boolean, options?: {
    answerOptions?: AnswerOption[] | string[];
    characters?: CharacterLike[];
    image?: string;
}): QuestionEvent | null;
/**
 * Simple activity event result - minimal fields for activity events
 * Can be converted to full MessageEventData when needed
 */
export interface ActivityEventResult {
    type: 'messageEvent';
    message: string;
    title?: string;
    image?: string;
    energyCost?: number;
    diamondCost?: number;
    moneyCost?: number;
    affinityChange?: number;
}
/**
 * Event result type - what event functions return
 */
export type EventResult = MessageEventData | QuestionEvent | ActivityEventResult | null;
/**
 * Event function signature
 */
export type EventFunction = (player: Player, type?: 'message' | 'question') => EventResult;
/**
 * Check probability - replaces Python's `1 >= random.random() * X` pattern
 */
export declare function checkProbability(oneInX: number): boolean;
/**
 * Safely modify a stat value, clamping to valid range (0-100)
 * @param currentValue - Current stat value
 * @param delta - Amount to add (positive) or subtract (negative)
 * @param min - Minimum allowed value (default 0)
 * @param max - Maximum allowed value (default 100)
 * @returns Clamped value
 */
export declare function modifyStat(currentValue: number | undefined, delta: number, min?: number, max?: number): number;
/**
 * Check milestone probability with increasing chance over time.
 *
 * Probability increases as the age window closes, guaranteeing the event
 * triggers before maxAge. Uses a "time remaining" formula:
 * - Early in window: low probability (natural variation)
 * - As window closes: probability automatically increases
 * - Near end: mathematically guaranteed to trigger
 *
 * @param currentAge - Current age (days or years, must match min/max units)
 * @param minAge - Minimum age for event to trigger
 * @param maxAge - Maximum age for event (deadline)
 * @param unit - 'days' or 'years' (affects hours calculation)
 * @returns true if event should trigger
 *
 * @example
 * // For learnedWalk (270-720 days)
 * checkMilestoneProbability(300, 270, 720, 'days')  // ~0.02% per hour
 * checkMilestoneProbability(700, 270, 720, 'days')  // ~0.2% per hour
 * checkMilestoneProbability(719, 270, 720, 'days')  // ~4% per hour
 */
export declare function checkMilestoneProbability(currentAge: number, minAge: number, maxAge: number, unit?: 'days' | 'years'): boolean;
export {};
//# sourceMappingURL=base.d.ts.map