/**
 * AuraGlass Quantum States System
 * Probabilistic UI states that collapse into deterministic visuals based on user interaction
 * Part of Next-Wave Systems (10/10) - Meta-Systems Framework
 */
import React from "react";
interface QuantumMeasurement<T = any> {
    stateId: string;
    measuredValue: T;
    probability: number;
    timestamp: number;
    observer: string;
    causedCollapse: boolean;
}
interface QuantumEntanglement {
    state1: string;
    state2: string;
    strength: number;
    correlationType: "positive" | "negative" | "complex";
    created: number;
    lastInteraction: number;
}
declare class ComplexNumber {
    real: number;
    imaginary: number;
    constructor(real?: number, imaginary?: number);
    static fromPolar(magnitude: number, phase: number): ComplexNumber;
    magnitude(): number;
    phase(): number;
    multiply(other: ComplexNumber): ComplexNumber;
    add(other: ComplexNumber): ComplexNumber;
    normalize(): ComplexNumber;
}
declare class QuantumStateVector {
    private amplitudes;
    private stateLabels;
    constructor(states: string[]);
    setAmplitude(stateIndex: number, amplitude: ComplexNumber): void;
    getAmplitude(stateIndex: number): ComplexNumber;
    getProbability(stateIndex: number): number;
    normalize(): void;
    measure(): {
        stateIndex: number;
        state: string;
        probability: number;
    };
    evolve(hamiltonianMatrix: number[][], timeStep: number): void;
    getSuperposition(): Array<{
        state: string;
        probability: number;
        amplitude: ComplexNumber;
    }>;
}
declare class QuantumUISystem {
    private quantumStates;
    private entanglements;
    private measurements;
    private interferenceGenerator;
    private decoherenceTimer;
    private hamiltonianMatrices;
    constructor();
    createQuantumState<T>(stateId: string, possibleStates: T[], initialProbabilities?: number[]): QuantumStateVector;
    private normalizeProbabilities;
    private createHamiltonianMatrix;
    private startQuantumEvolution;
    measureState(stateId: string, observer?: string): QuantumMeasurement | null;
    private handleEntangledMeasurements;
    private scheduleDecoherence;
    private restoreSuperposition;
    createEntanglement(state1: string, state2: string, strength?: number, type?: "positive" | "negative" | "complex"): void;
    getSuperposition(stateId: string): Array<{
        state: any;
        probability: number;
        phase: number;
    }> | null;
    generateInterferencePattern(width: number, height: number, time: number): number[][];
    getQuantumCoherence(stateId: string): number;
    getStateVector(stateId: string): QuantumStateVector | undefined;
    getAllMeasurements(): QuantumMeasurement[];
    getEntanglements(): QuantumEntanglement[];
    cleanup(stateId: string): void;
}
export declare function GlassQuantumStatesProvider({ children, onMeasurement, onStateChange, }: {
    children: React.ReactNode;
    onMeasurement?: (measurement: QuantumMeasurement) => void;
    onStateChange?: (stateId: string, superposition: any[]) => void;
}): import("react/jsx-runtime").JSX.Element;
export declare function useQuantumStates(): {
    system: QuantumUISystem | null;
    createQuantumState: <T>(stateId: string, possibleStates: T[], initialProbabilities?: number[]) => void;
    measureState: (stateId: string, observer?: string) => QuantumMeasurement | null;
    getSuperposition: (stateId: string) => Array<{
        state: any;
        probability: number;
        phase: number;
    }> | null;
    createEntanglement: (state1: string, state2: string, strength?: number, type?: "positive" | "negative" | "complex") => void;
    getCoherence: (stateId: string) => number;
};
export declare function GlassQuantumButton({ children, possibleStates, onCollapse, className, stateId, ...props }: {
    children: React.ReactNode;
    possibleStates: Array<{
        label: string;
        color: string;
        action: () => void;
    }>;
    onCollapse?: (selectedState: any) => void;
    className?: string;
    stateId?: string;
} & React.ButtonHTMLAttributes<HTMLButtonElement>): import("react/jsx-runtime").JSX.Element;
export declare function QuantumInterferencePattern({ width, height, speed, visible, className, }: {
    width?: number;
    height?: number;
    speed?: number;
    visible?: boolean;
    className?: string;
}): import("react/jsx-runtime").JSX.Element;
export declare function GlassQuantumEntangledPair({ children, stateId1, stateId2, possibleStates, entanglementType, entanglementStrength, className, }: {
    children: [React.ReactNode, React.ReactNode];
    stateId1: string;
    stateId2: string;
    possibleStates: any[];
    entanglementType?: "positive" | "negative" | "complex";
    entanglementStrength?: number;
    className?: string;
}): import("react/jsx-runtime").JSX.Element;
export declare function GlassQuantumCoherenceIndicator({ stateId, className, }: {
    stateId: string;
    className?: string;
}): import("react/jsx-runtime").JSX.Element;
export declare function useQuantumState<T>(stateId: string, possibleStates: T[], initialProbabilities?: number[]): {
    measure: (observer?: string) => any;
    collapse: (targetState: T) => void;
    currentMeasurement: T | null;
    superposition: {
        state: T;
        probability: number;
        phase: number;
    }[];
    isInSuperposition: boolean;
    dominantState: {
        state: T;
        probability: number;
        phase: number;
    } | null;
};
export declare const quantumStatePresets: {
    binary: {
        states: boolean[];
        initialProbabilities: number[];
        decoherenceTime: number;
    };
    ternary: {
        states: string[];
        initialProbabilities: number[];
        decoherenceTime: number;
    };
    emotional: {
        states: string[];
        initialProbabilities: number[];
        decoherenceTime: number;
    };
    interface: {
        states: string[];
        initialProbabilities: number[];
        decoherenceTime: number;
    };
};
export declare function GlassQuantumStates({ children, className, ...props }: {
    children?: React.ReactNode;
    className?: string;
} & React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
export {};
//# sourceMappingURL=GlassQuantumStates.d.ts.map