/**
 * Attention Economics & Token Optimization
 *
 * Intelligent token allocation that mimics brain attention.
 * Compresses familiar patterns, expands novel ones.
 */
export declare class AttentionEconomics {
    private totalAttention;
    private allocations;
    private history;
    constructor(totalAttention?: number);
    /**
     * Allocate attention across agents based on multiple factors
     */
    allocate(agents: Array<{
        id: string;
        performance: number;
        reliability: number;
        urgency: number;
        potential: number;
    }>): Map<string, number>;
    /**
     * Get current allocation for an agent
     */
    getAllocation(agentId: string): number;
    /**
     * Record agent performance for future allocation
     */
    recordPerformance(agentId: string, value: number): void;
    /**
     * Get average performance
     */
    getAveragePerformance(agentId: string): number;
}
export declare class TokenOptimizer {
    private maxTokens;
    private compressionDictionary;
    private familiarityScores;
    constructor(maxTokens?: number);
    /**
     * Optimize token allocation for a task
     */
    optimize(task: string, context: string[]): {
        tokens: number;
        strategy: 'compress' | 'expand' | 'standard';
        breakdown: Array<{
            part: string;
            tokens: number;
        }>;
    };
    /**
     * Compress tokens using learned dictionary
     */
    compress(text: string): string;
    /**
     * Expand compressed tokens back to text
     */
    expand(compressed: string): string;
    /**
     * Update compression dictionary
     */
    updateDictionary(phrase: string, token: string): void;
    /**
     * Speculate: generate variations for novel situations
     */
    speculate(text: string, n?: number): string[];
    /**
     * Rank speculations by potential
     */
    rankByPotential(variations: string[]): string[];
    private decompose;
    private estimateComplexity;
    private computeRelevance;
    private isFamiliar;
    private isNovel;
    markFamiliar(subtask: string): void;
    markNovel(subtask: string): void;
}
export declare class InfiniteContext {
    private attentionBudget;
    private index;
    private attentionRouter;
    constructor(attentionBudget?: number);
    /**
     * Index content for retrieval
     */
    indexContent(key: string, content: string[]): void;
    /**
     * Think: retrieve relevant context regardless of "distance"
     */
    think(query: string, maxItems?: number): string[];
    /**
     * Update attention weights
     */
    updateAttention(key: string, value: number): void;
}
export declare const createAttentionEconomics: (totalAttention?: number) => AttentionEconomics;
export declare const createTokenOptimizer: (maxTokens?: number) => TokenOptimizer;
export declare const createInfiniteContext: (attentionBudget?: number) => InfiniteContext;
