/**
 * Offline Event Queue System
 * Manages event queuing and replay for offline players.
 *
 * Ported from Python: ws/performance/offline/queue.py
 */
import { Player } from '../../models/Player.js';
export interface QueuedEvent {
    type: string;
    id: string;
    message?: string;
    data?: Record<string, unknown>;
    queuedAt: number;
}
export interface OfflineQueueStats {
    offlinePlayers: number;
    totalQueuedEvents: number;
    maxQueueSize: number;
    maxOfflineHours: number;
}
export interface ReconnectInfo {
    offlineDurationSeconds: number | null;
    offlineDurationHours: number;
    queuedEvents: QueuedEvent[];
    eventCount: number;
}
/**
 * Manages queuing of events that occur while a player is offline.
 * Events are stored and replayed when the player reconnects.
 */
export declare class OfflineEventQueue {
    private maxQueueSize;
    private maxOfflineHours;
    private queues;
    private offlineSince;
    /**
     * Initialize the offline event queue.
     *
     * @param maxQueueSize - Maximum events to queue per player (default: 1000)
     * @param maxOfflineHours - Maximum hours to keep offline events (default: 168 = 7 days)
     */
    constructor(maxQueueSize?: number, maxOfflineHours?: number);
    /**
     * Mark a player as offline and start queuing events.
     *
     * @param playerId - Player's unique identifier
     */
    markOffline(playerId: string): void;
    /**
     * Mark a player as online and return queued events.
     *
     * @param playerId - Player's unique identifier
     * @returns List of queued events to replay
     */
    markOnline(playerId: string): QueuedEvent[];
    /**
     * Check if a player is currently marked as offline.
     *
     * @param playerId - Player's unique identifier
     * @returns True if player is offline
     */
    isOffline(playerId: string): boolean;
    /**
     * Queue an event for an offline player.
     *
     * @param playerId - Player's unique identifier
     * @param event - Event data to queue
     * @returns True if queued, false if player is online or queue full
     */
    queueEvent(playerId: string, event: Omit<QueuedEvent, 'queuedAt'>): boolean;
    /**
     * Get how long a player has been offline in seconds.
     *
     * @param playerId - Player's unique identifier
     * @returns Offline duration in seconds, or null if online
     */
    getOfflineDuration(playerId: string): number | null;
    /**
     * Clear all queued events for a player.
     *
     * @param playerId - Player's unique identifier
     */
    clearQueue(playerId: string): void;
    /**
     * Get number of queued events for a player.
     *
     * @param playerId - Player's unique identifier
     * @returns Number of queued events
     */
    getQueueSize(playerId: string): number;
    /**
     * Get queue statistics.
     *
     * @returns Dictionary with queue stats
     */
    getStats(): OfflineQueueStats;
    /**
     * Remove queues for players offline longer than maxOfflineHours.
     *
     * @returns Number of expired queues removed
     */
    cleanupExpired(): number;
    /**
     * Get all offline player IDs.
     *
     * @returns Array of offline player IDs
     */
    getOfflinePlayerIds(): string[];
}
/**
 * Get the global offline queue instance.
 */
export declare function getOfflineQueue(): OfflineEventQueue;
/**
 * Handle player disconnection - start queuing events.
 *
 * @param playerId - Player's unique identifier
 */
export declare function handlePlayerDisconnect(playerId: string): void;
/**
 * Handle player reconnection - return queued events and stats.
 *
 * @param playerId - Player's unique identifier
 * @returns Dictionary with offline duration and queued events
 */
export declare function handlePlayerReconnect(playerId: string): ReconnectInfo;
/**
 * Replay queued events to a player after reconnection.
 *
 * @param playerId - Player's unique identifier
 * @param sendEvent - Function to send each event to the player
 * @returns Number of events replayed
 */
export declare function replayEvents(playerId: string, sendEvent: (event: QueuedEvent) => Promise<void>): Promise<number>;
export interface IterateGamesOptions {
    loadGames: () => Promise<Array<{
        playerId: string;
    }>>;
    loadGameAsync: (playerId: string) => Promise<Player | null>;
    saveGameAsync: (player: Player) => Promise<void>;
    processGameTick: (player: Player) => Promise<void>;
}
/**
 * Iterate through all saved games and process one tick for disconnected players.
 *
 * This function loads all games from the database and runs offline simulation
 * for players who are disconnected. Used for background game progression.
 *
 * Ported from Python: ws/game_loop/loop_manager.py -> iterateGames()
 */
export declare function iterateGames(options: IterateGamesOptions): Promise<void>;
/**
 * Register offline queue maintenance jobs.
 *
 * @param intervalMs - Interval for cleanup job (default: 1 hour)
 */
export declare function registerOfflineQueueJobs(intervalMs?: number): void;
export declare const offlineQueueService: {
    OfflineEventQueue: typeof OfflineEventQueue;
    getOfflineQueue: typeof getOfflineQueue;
    handlePlayerDisconnect: typeof handlePlayerDisconnect;
    handlePlayerReconnect: typeof handlePlayerReconnect;
    replayEvents: typeof replayEvents;
    iterateGames: typeof iterateGames;
    registerOfflineQueueJobs: typeof registerOfflineQueueJobs;
};
//# sourceMappingURL=offline_queue.d.ts.map