/**
 * 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 = unknown> {
    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;
}
export interface QuantumSuperpositionEntry<T = unknown> {
    state: T;
    probability: number;
    phase: number;
}
export interface QuantumButtonState {
    label: string;
    color: string;
    action: () => void;
}
interface QuantumStatesContextValue {
    system: QuantumUISystem | null;
    createQuantumState: <T>(stateId: string, possibleStates: T[], initialProbabilities?: number[]) => void;
    measureState: <T = unknown>(stateId: string, observer?: string) => QuantumMeasurement<T> | null;
    getSuperposition: <T = unknown>(stateId: string) => QuantumSuperpositionEntry<T>[] | null;
    createEntanglement: (state1: string, state2: string, strength?: number, type?: QuantumEntanglement["correlationType"]) => void;
    getCoherence: (stateId: string) => 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<T = unknown>(stateId: string, observer?: string): QuantumMeasurement<T> | null;
    private handleEntangledMeasurements;
    private scheduleDecoherence;
    private restoreSuperposition;
    createEntanglement(state1: string, state2: string, strength?: number, type?: "positive" | "negative" | "complex"): void;
    getSuperposition<T = unknown>(stateId: string): QuantumSuperpositionEntry<T>[] | 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: QuantumSuperpositionEntry[]) => void;
}): import("react/jsx-runtime").JSX.Element;
export declare function useQuantumStates(): QuantumStatesContextValue;
export declare function GlassQuantumButton({ children, possibleStates, onCollapse, className, stateId, ...props }: {
    children: React.ReactNode;
    possibleStates: QuantumButtonState[];
    onCollapse?: (selectedState: QuantumButtonState) => 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: unknown[];
    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) => T | null;
    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