import { Event, PlayerContext, GeneratorOptions, ExportData, ImportResult, GameState, WorldGenerationOptions } from './types';
export declare class RPGEventGenerator {
    private generatorCore;
    private markovEngine;
    private contextAnalyzer;
    private difficultyScaler;
    private templateSystem;
    private chainSystem;
    private ruleEngine;
    private environmentalSystem;
    private timeSystem;
    private relationshipSystem;
    private localizationSystem;
    private aiEnhancer;
    private worldBuildingSystem;
    private templateDatabase;
    private options;
    private rng;
    private enableTemplates;
    private enableDependencies;
    private _enableModifiers;
    private _enableRelationships;
    private pureMarkovMode;
    private _enableRuleEngine;
    constructor(options?: GeneratorOptions);
    /**
     * Validate configuration options
     */
    private validateConfig;
    /**
     * Initialize all systems with provided options
     */
    private initializeSystems;
    /**
     * Generate a single event
     */
    generateEvent(playerContext?: PlayerContext): Event;
    /**
     * Try to generate an event from a matching template
     */
    private tryGenerateFromTemplate;
    /**
     * Check if a template matches the player context
     */
    private templateMatchesContext;
    /**
     * Generate multiple events
     */
    generateEvents(playerContext?: PlayerContext, count?: number): Event[];
    /**
     * Generate event from specific template (supports custom templates)
     */
    generateFromTemplate(templateId: string, context?: PlayerContext): Event | null;
    /**
     * Generate random event from genre (backward compatibility - removed)
     */
    generateFromGenre(genre: string, context?: PlayerContext): Event | null;
    /**
     * Register a custom template
     */
    registerEventTemplate(templateId: string, template: any): boolean;
    /**
     * Unregister a custom template
     */
    unregisterEventTemplate(templateId: string): boolean;
    /**
     * Get list of custom templates
     */
    getCustomTemplates(): string[];
    /**
     * Get available templates by genre (pre-built library removed)
     */
    getAvailableTemplates(): any;
    /**
     * Start an event chain
     */
    startChain(chainId: string, playerContext?: PlayerContext): Event | null;
    /**
     * Advance an event chain
     */
    advanceChain(chainId: string, choice: string): Event | null;
    /**
     * Get active chains
     */
    getActiveChains(): any[];
    /**
     * End a chain
     */
    endChain(chainId: string): void;
    /**
     * Add a custom rule
     */
    addCustomRule(name: string, rule: any): void;
    /**
     * Remove a custom rule
     */
    removeCustomRule(name: string): boolean;
    /**
     * Get custom rules
     */
    getCustomRules(): any;
    /**
     * Validate a custom rule
     */
    validateCustomRule(rule: any): {
        isValid: boolean;
        errors: string[];
    };
    /**
     * Set environmental context
     */
    setEnvironmentalContext(context: any): void;
    /**
     * Register custom environmental modifier
     */
    registerModifier(modifierId: string, modifierConfig: any): void;
    /**
     * Get current time information
     */
    getCurrentTime(): any;
    /**
     * Advance game time by one day
     */
    advanceGameDay(): any[];
    /**
     * Advance game time by multiple days
     */
    advanceGameDays(days: number): any[];
    /**
     * Start a time-based chain
     */
    startTimeBasedChain(chainName: string): boolean;
    /**
     * Get active time chains
     */
    getActiveTimeChains(): any[];
    /**
     * Add an NPC to the relationship system
     */
    addNPC(npcConfig: any): void;
    /**
     * Update relationship between NPCs
     */
    updateRelationship(npcId: string, targetId: string, change: number, reason: string): void;
    /**
     * Get relationship between NPCs
     */
    getRelationship(npcId: string, targetId: string): any;
    /**
     * Apply relationship rule
     */
    applyRelationshipRule(npcId: string, targetId: string, ruleId: string): void;
    /**
     * Load a language pack
     */
    loadLanguagePack(language: string, languagePack: any): void;
    /**
     * Set current language
     */
    setLanguage(language: string): boolean;
    /**
     * Get translated text
     */
    translate(key: string, variables?: any): string;
    /**
     * Export custom content
     */
    exportCustomContent(): ExportData;
    /**
     * Import custom content
     */
    importCustomContent(data: ExportData): ImportResult;
    get enableRuleEngine(): boolean;
    get enableModifiers(): boolean;
    get enableRelationships(): boolean;
    /**
     * Get system statistics
     */
    getSystemStatus(): any;
    /**
     * Get game state for saving
     */
    getGameState(): GameState;
    /**
     * Load game state
     */
    loadGameState(gameState: GameState): boolean;
    addTrainingData(texts: string[]): void;
    addCustomTrainingData(texts: string[], theme?: string): void;
    generateTimeAwareEvent(context?: PlayerContext): Event;
    generateEnhancedEvent(context?: PlayerContext, options?: any): Event;
    applyModifiers(event: Event, modifiers?: any[]): Event;
    registerEventDependency(eventId: string, dependency: any): void;
    checkEventDependencies(eventId: string, playerState?: any): boolean;
    getRelationshipSummary(npcId: string): any;
    advanceTime(days: number): any[];
    getRelationshipNetwork(npcId: string, depth?: number): any;
    /**
     * Scale effects for difficulty (backward compatibility - stub)
     */
    scaleEffectsForDifficulty(effects: any, difficulty: string): any;
    /**
     * Calculate difficulty tier (backward compatibility - stub)
     */
    calculateDifficultyTier(powerLevel: number): string;
    /**
     * Register event chain (backward compatibility)
     */
    registerEventChain(id: string, chain: any): boolean;
    /**
     * Clear custom rules (backward compatibility - stub)
     */
    clearCustomRules(): void;
    /**
     * Clear all template caches
     */
    clearTemplateCaches(): void;
    /**
     * Get template cache statistics
     */
    getTemplateCacheStats(): {
        processedTemplates: number;
        generatedEvents: number;
    };
    generateWorld(seedOrOptions?: number | WorldGenerationOptions): any;
    getWorldLore(location: string): string | null;
    getWorldRegion(id: string): any;
    getWorldFaction(id: string): any;
    getAllWorldRegions(): any[];
    getAllWorldFactions(): any[];
    getHistoricalEvents(): any[];
    simulateWorldYears(years: number): any[];
    getFactionRelationships(factionId: string): any;
    getRegionResources(regionId: string): any[];
    getWorldStats(): any;
    getFactionAllies(factionId: string): string[];
    getFactionEnemies(factionId: string): string[];
    getFactionDiplomacyStatus(factionId1: string, factionId2: string): string;
    calculateFactionInfluence(factionId: string): number;
    getFactionTradeRoutes(factionId: string): any[];
    getFactionPowerRanking(): any[];
    getFactionGoals(factionId: string): string[];
    updateFactionRelationship(factionId1: string, factionId2: string, change: number): boolean;
    getFactionNetwork(factionId: string, depth?: number): any;
    /**
     * Generate multiple events in parallel using Web Workers (if available)
     *
     * Falls back to sequential generation if:
     * - Web Workers are not supported in the environment
     * - Worker spawning fails
     *
     * @param count - Number of events to generate
     * @param context - Player context for event generation
     * @param options - Options including maxWorkers (defaults to min of CPU count and 4)
     * @returns Promise resolving to array of generated events
     * @throws Never throws; always falls back to sequential generation on error
     */
    generateEventsParallel(count: number, context?: PlayerContext, options?: {
        maxWorkers?: number;
    }): Promise<Event[]>;
    /**
     * Generate multiple events sequentially
     *
     * @param count - Number of events to generate
     * @param context - Player context for event generation
     * @returns Promise resolving to array of generated events
     */
    private generateEventsSequential;
    private spawnEventGenerationWorker;
    generateEventsBatched(count: number, context?: PlayerContext, batchSize?: number): Event[];
    private initializeDatabase;
    private initializeDatabaseSync;
    storeTemplateInDatabase(template: any): Promise<void>;
    getTemplateFromDatabase(id: string): Promise<any | null>;
    searchTemplatesInDatabase(criteria: any): Promise<any[]>;
    getTemplatesByTags(tags: string[]): Promise<any[]>;
    getRandomTemplatesFromDatabase(count: number, criteria?: any): Promise<any[]>;
    getDatabaseStats(): Promise<any>;
    /**
     * Check if running in a Node.js environment (for testing)
     */
    get isNodeEnv(): boolean;
    /**
     * Get optimal worker count based on environment (for testing)
     */
    getOptimalWorkerCount(): number;
}
//# sourceMappingURL=RPGEventGenerator.d.ts.map