import { M as Modality, e as GradientEnvelope, B as BaseStorage, R as RLHFFeedback } from '../../base-storage-CfkDwX0r.mjs';

/**
 * Reward Model
 *
 * Lightweight neural network that predicts reward from hidden states.
 * Trained on-device using user feedback.
 */
interface RewardModelConfig {
    inputDim: number;
    hiddenDim?: number;
    learningRate?: number;
}
declare class RewardModel {
    private inputDim;
    private hiddenDim;
    private learningRate;
    private w1;
    private b1;
    private w2;
    private b2;
    private dw1;
    private db1;
    private dw2;
    private db2;
    private gradCount;
    constructor(config: RewardModelConfig);
    /**
     * Forward pass: hidden state -> reward prediction
     */
    forward(hiddenState: Float32Array): number;
    /**
     * Backward pass: compute gradients from feedback
     */
    backward(hiddenState: Float32Array, targetReward: number): void;
    /**
     * Apply accumulated gradients
     */
    applyGradients(): void;
    /**
     * Get gradient update for federated learning
     */
    getGradientUpdate(): ArrayBuffer;
    /**
     * Apply gradient update from federated learning
     */
    applyGradientUpdate(update: ArrayBuffer): void;
    /**
     * Save weights to ArrayBuffer
     */
    getWeights(): ArrayBuffer;
    /**
     * Load weights from ArrayBuffer
     */
    loadWeights(weights: ArrayBuffer): void;
}

/**
 * Federated Sync
 *
 * Privacy-preserving synchronization of adapter updates.
 */

interface FederatedSyncConfig {
    hubUrl: string;
    modelId: string;
    deviceId: string;
    epsilon?: number;
    clipNorm?: number;
    noiseMultiplier?: number;
    minCohort?: number;
}
interface GradientUpdate {
    gradients: ArrayBuffer;
    feedbackCount: number;
    deviceId: string;
    modelId: string;
    modality: Modality;
    baseVersion: string;
    adapterBaseVersion: string;
}
declare class FederatedSync {
    private hubUrl;
    private modelId;
    private deviceId;
    private epsilon;
    private clipNorm;
    private noiseMultiplier;
    private minCohort;
    constructor(config: FederatedSyncConfig);
    /**
     * Clip gradients to a fixed L2 norm bound.
     */
    private clipGradients;
    /**
     * Add differential privacy noise to gradients
     */
    private addDifferentialPrivacyNoise;
    /**
     * Build a gradient envelope compatible with D1/Dash sync metadata.
     */
    buildEnvelope(update: GradientUpdate, deviceProof: string): GradientEnvelope;
    /**
     * Send gradient update to hub
     */
    sendUpdate(update: GradientUpdate): Promise<void>;
    /**
     * Fetch aggregated update from hub
     */
    fetchAggregatedUpdate(): Promise<ArrayBuffer | null>;
    /**
     * Full sync cycle: send local update, receive aggregated
     */
    sync(localUpdate: GradientUpdate): Promise<ArrayBuffer | null>;
}

/**
 * RLHF Trainer
 *
 * Manages on-device training from user feedback.
 */

interface RLHFTrainerConfig {
    storage: BaseStorage;
    modelId: string;
    userId: string;
    hiddenDim: number;
    modality?: Modality;
    learningRate?: number;
    batchSize?: number;
    federatedSync?: FederatedSync;
    communityParticipation?: boolean;
}
declare class RLHFTrainer {
    private storage;
    private modelId;
    private userId;
    private modality;
    private rewardModel;
    private batchSize;
    private adapterId;
    private pendingFeedback;
    private trainingExamples;
    private lastTrained?;
    private federatedSync;
    private communityParticipation;
    constructor(config: RLHFTrainerConfig);
    /**
     * Initialize trainer and load existing adapter if available
     */
    initialize(): Promise<void>;
    /**
     * Record feedback for a response
     */
    recordFeedback(feedback: RLHFFeedback): Promise<void>;
    /**
     * Train on accumulated feedback
     */
    train(batchSize?: number): Promise<void>;
    /**
     * Predict reward for a hidden state
     */
    predict(hiddenState: Float32Array): number;
    /**
     * Get adapter weights for sync
     */
    getAdapterWeights(): Promise<ArrayBuffer>;
    /**
     * Load adapter weights
     */
    loadAdapterWeights(weights: ArrayBuffer): Promise<void>;
    /**
     * Get gradient update for federated learning
     */
    getGradientUpdate(): ArrayBuffer;
    /**
     * Apply gradient update from federated learning
     */
    applyGradientUpdate(update: ArrayBuffer): Promise<void>;
    /**
     * Get training statistics
     */
    getStats(): {
        examples: number;
        lastTrained?: string;
    };
    /**
     * Save adapter to storage
     */
    private saveAdapter;
    /**
     * Sync adapter updates with server (federated learning)
     */
    syncUpdates(): Promise<void>;
    /**
     * Enable/disable community update sharing.
     */
    setCommunityParticipation(enabled: boolean): void;
    /**
     * Build a signed envelope payload for external aggregation services.
     */
    toGradientEnvelope(deviceProof: string, dpNoiseSeedId: string): GradientEnvelope;
}

export { FederatedSync, RLHFTrainer, RewardModel };