/**
 * Agentic QE v3 - Value Network for Neural Topology Optimizer
 * ADR-034: RL-based swarm topology optimization
 *
 * Implements a neural network for estimating state values using:
 * - Xavier/He initialization for stable gradients
 * - ReLU activation for hidden layer
 * - Backpropagation with TD error
 * - Optional target network for stability
 */
import type { IValueNetwork } from './types';
/**
 * Neural network for estimating state values
 *
 * Architecture: Input -> Hidden (ReLU) -> Output
 *
 * Uses TD learning to update weights based on temporal difference errors.
 */
export declare class ValueNetwork implements IValueNetwork {
    /** Hidden layer weights [hiddenSize][inputSize] */
    private wHidden;
    /** Hidden layer biases [hiddenSize] */
    private bHidden;
    /** Output layer weights [hiddenSize] */
    private wOutput;
    /** Output layer bias */
    private bOutput;
    /** Last computed value (for debugging) */
    private lastEstimate;
    /** Input dimension */
    private readonly inputSize;
    /** Hidden dimension */
    private readonly hiddenSize;
    /** Gradient clipping threshold */
    private readonly gradientClip;
    constructor(inputSize: number, hiddenSize: number);
    /**
     * Generate random number from standard normal distribution
     * Using Box-Muller transform
     */
    private randn;
    /**
     * Clip value to prevent gradient explosion
     */
    private clip;
    /**
     * ReLU activation function
     */
    private relu;
    /**
     * ReLU derivative
     */
    private reluDerivative;
    /**
     * Forward pass to estimate value of a state
     *
     * @param state - State vector (length should match inputSize)
     * @returns Estimated value
     */
    estimate(state: number[]): number;
    /**
     * Update weights using TD error via backpropagation
     *
     * Uses semi-gradient TD(0) update:
     * w <- w + alpha * tdError * gradient
     *
     * @param state - State that was evaluated
     * @param tdError - Temporal difference error (reward + gamma * V(s') - V(s))
     * @param lr - Learning rate
     */
    update(state: number[], tdError: number, lr: number): void;
    /**
     * Copy weights from another network (for target network updates)
     */
    copyFrom(other: IValueNetwork): void;
    /**
     * Soft update from another network (Polyak averaging)
     *
     * w <- tau * w_other + (1 - tau) * w
     */
    softUpdate(other: IValueNetwork, tau?: number): void;
    /**
     * Export weights for serialization
     */
    export(): {
        wHidden: number[][];
        bHidden: number[];
        wOutput: number[];
        bOutput: number;
    };
    /**
     * Import weights from serialized data
     */
    import(weights: {
        wHidden: number[][];
        bHidden: number[];
        wOutput: number[];
        bOutput: number;
    }): void;
    /**
     * Get last computed estimate (for debugging)
     */
    getLastEstimate(): number;
    /**
     * Get network dimensions
     */
    getDimensions(): {
        inputSize: number;
        hiddenSize: number;
    };
    /**
     * Calculate L2 norm of all weights (for regularization/monitoring)
     */
    getWeightNorm(): number;
}
/**
 * Create a new value network
 */
export declare function createValueNetwork(inputSize: number, hiddenSize: number): ValueNetwork;
/**
 * Create a value network from exported weights
 */
export declare function createValueNetworkFromWeights(weights: {
    wHidden: number[][];
    bHidden: number[];
    wOutput: number[];
    bOutput: number;
}): ValueNetwork;
//# sourceMappingURL=value-network.d.ts.map