/**
 * Trigger Module - Generic timing and event system
 *
 * Phase 6.1: Generic trigger module for time-based, event-based, and proximity-based activation.
 * Designed to be reusable across the engine, not just for spawners.
 *
 * Architecture:
 * - Follows Module base class pattern
 * - Supports multiple trigger types (time, interval, event, proximity)
 * - Serializable state for save/load
 * - Callback-based execution for flexibility
 * - Independent of spawner module for reusability
 */
import { Module } from "./Module";
import { ECSContext } from "../core/ecs";
import { ConditionDefinition, ConditionEvaluationTrace } from "./condition";
import { MetricsKey } from "../core/metrics";
/** Position for proximity triggers */
export interface Position {
    x: number;
    y: number;
    z: number;
}
/**
 * Trigger definition types
 * - immediate: Fire immediately on registration
 * - time: Fire after a delay (one-shot)
 * - interval: Fire repeatedly at intervals
 * - event: Fire when a named event occurs
 * - proximity: Fire when position is near trigger point (TODO: Phase 8)
 */
export type TriggerDefinition = {
    type: "immediate";
    params: {};
} | {
    type: "time";
    params: {
        /** Delay in seconds before firing */
        delay: number;
    };
} | {
    type: "interval";
    params: {
        /** Interval in seconds between firings */
        interval: number;
        /** Optional: maximum number of times to fire (undefined = infinite) */
        maxCount?: number;
        /** Optional: initial delay before first firing */
        initialDelay?: number;
    };
} | {
    type: "event";
    params: {
        /** Event name to listen for */
        event: string;
        /** Optional: only fire once */
        once?: boolean;
    };
} | {
    type: "proximity";
    params: {
        /** Position to check proximity to */
        position: Position;
        /** Radius for proximity check */
        radius: number;
        /** Optional: only fire once */
        once?: boolean;
    };
} | {
    type: "condition";
    params: {
        /** Subject entity ID to evaluate condition against */
        subject: MetricsKey;
        /** Condition to evaluate */
        condition: ConditionDefinition;
        /** Check interval in seconds (how often to evaluate the condition) */
        checkInterval?: number;
        /** Optional: only fire once */
        once?: boolean;
    };
};
/**
 * @deprecated Triggers no longer use callbacks. Systems should check hasFired flag.
 * This type is kept for backward compatibility but should not be used.
 */
export type TriggerCallback = (ctx: ECSContext, triggerName: string, data?: any) => void;
/**
 * Runtime trigger state
 * Tracks execution state and timing
 *
 * NO CALLBACKS: Systems should check hasFired and react accordingly.
 * This follows ECS pattern and ensures full serializability.
 */
export interface TriggerState {
    /** Trigger definition */
    definition: TriggerDefinition;
    /** Whether trigger is active (can fire) */
    isActive: boolean;
    /** Whether trigger has completed (for one-shot triggers) */
    isComplete: boolean;
    /** Time since trigger was registered (seconds) */
    timeSinceStart: number;
    /** Time since last firing (seconds) - for interval triggers */
    timeSinceLastFire: number;
    /** Number of times trigger has fired */
    fireCount: number;
    /** Whether trigger has fired this frame (reset each frame) */
    hasFired: boolean;
    /** Most recent condition evaluation trace (condition triggers only) */
    lastConditionTrace?: ConditionEvaluationTrace;
}
/**
 * Serializable trigger state for save/load
 */
export interface SerializedTriggerState {
    isActive: boolean;
    isComplete: boolean;
    timeSinceStart: number;
    timeSinceLastFire: number;
    fireCount: number;
}
/**
 * TriggerModule - Manages time-based, event-based, and proximity-based triggers
 *
 * Follows Module base class pattern for consistency with engine architecture.
 * Can be used by any system that needs timing/event functionality.
 *
 * Features:
 * - Multiple trigger types (immediate, time, interval, event, proximity)
 * - Callback-based execution
 * - Active/paused state management
 * - Serialization support for save/load
 * - Event emission and subscription
 *
 * Usage:
 * ```typescript
 * // Get the trigger module (automatically initialized)
 * const trigger = getModule(ctx, 'trigger');
 *
 * // Register a time-based trigger using standard module pattern
 * trigger.register('spawn_wave', {
 *   type: 'time',
 *   params: { delay: 30 }
 * }, (ctx, name) => {
 *   console.log('Wave triggered!');
 * });
 *
 * // Trigger updates automatically via updateTriggerSystem
 * // Or manually call: trigger.update(deltaTime);
 * ```
 */
export declare class TriggerModule extends Module<TriggerDefinition, TriggerState> {
    private eventListeners;
    constructor(ctx: ECSContext);
    /**
     * Create initial trigger state for a given type
     */
    private createTriggerState;
    /**
     * Get trigger state by name (from base Module registry)
     */
    private getTriggerState;
    /**
     * Get all registered trigger names
     */
    private getAllTriggerNames;
    /**
     * Register a trigger using the standard module pattern
     *
     * NO CALLBACKS: Systems should check hasFired flag and react.
     * This ensures full serializability and follows ECS patterns.
     */
    register(name: string, def: TriggerDefinition): TriggerState;
    register(name: string, baseName: string, overrides: Partial<TriggerDefinition>): TriggerState;
    /**
     * Reset all hasFired flags at the start of each frame
     * Should be called by the trigger system before processing triggers
     */
    resetFiredFlags(): void;
    /**
     * Update all active triggers
     * Call this every frame from a system
     *
     * @param deltaTime Time elapsed since last update (seconds)
     */
    update(deltaTime: number): void;
    /**
     * Fire a trigger manually
     * Internal use for timer-based triggers, can also be called externally
     *
     * @param name Trigger name
     */
    /**
     * Fire a trigger - sets hasFired flag for systems to check
     * No callbacks - follows ECS pattern where systems poll state
     */
    private fireTrigger;
    /**
     * Emit an event to fire all event-based triggers listening for it
     *
     * @param eventName Name of the event
     */
    emit(eventName: string): void;
    /**
     * Manually fire a trigger by name
     * Useful for testing or manual control
     *
     * @param name Trigger name
     */
    fire(name: string): void;
    /**
     * Pause a trigger (prevents it from firing)
     *
     * @param name Trigger name
     */
    pause(name: string): void;
    /**
     * Resume a paused trigger
     *
     * @param name Trigger name
     */
    resume(name: string): void;
    /**
     * Reset a trigger to initial state
     *
     * @param name Trigger name
     */
    reset(name: string): void;
    /**
     * Remove a trigger
     *
     * @param name Trigger name
     */
    remove(name: string): void;
    /**
     * Get trigger state
     *
     * @param name Trigger name
     * @returns Trigger state or undefined if not found
     */
    getState(name: string): TriggerState | undefined;
    /**
     * Check if trigger is active
     *
     * @param name Trigger name
     * @returns True if trigger is active and not complete
     */
    isActive(name: string): boolean;
    /**
     * Check if trigger is complete
     *
     * @param name Trigger name
     * @returns True if trigger has completed
     */
    isComplete(name: string): boolean;
    /**
     * Get all trigger names
     *
     * @returns Array of trigger names
     */
    getTriggerNames(): string[];
    /**
     * Serialize trigger states for save/load
     *
     * @returns Serialized state map
     */
    serializeState(): Record<string, SerializedTriggerState>;
    /**
     * Clear all triggers
     */
    clear(): void;
}
export declare const triggerModule: (ctx: ECSContext) => TriggerModule;
//# sourceMappingURL=trigger.d.ts.map