aura-glass/dist/types/consciousness.d.ts

A comprehensive glassmorphism design system for React applications with 142+ production-ready components

/**
 * Unified API Design for Consciousness Interface Features
 * Standardized types and interfaces across the component library
 */
export interface BaseConsciousnessFeatures {
    /** Enable predictive behavior analysis and preloading */
    predictive?: boolean;
    /** Enable eye tracking and gaze-responsive interactions */
    eyeTracking?: boolean;
    /** Enable biometric adaptation based on user state */
    adaptive?: boolean;
    /** Enable spatial audio positioning and feedback */
    spatialAudio?: boolean;
    /** Enable achievement system integration */
    trackAchievements?: boolean;
}
export interface ExtendedConsciousnessFeatures extends BaseConsciousnessFeatures {
    /** Preload related data/content when predictive is enabled */
    preloadData?: boolean;
    /** Preload navigation routes when predictive is enabled */
    preloadRoutes?: boolean;
    /** Preload form actions when predictive is enabled */
    preloadActions?: boolean;
    /** Respond to user gaze with visual feedback when eyeTracking is enabled */
    gazeResponsive?: boolean;
    /** Highlight elements based on gaze when eyeTracking is enabled */
    gazeHighlight?: boolean;
    /** Show focus previews when eyeTracking is enabled */
    focusPreview?: boolean;
    /** Enable gaze-based navigation when eyeTracking is enabled */
    gazeNavigation?: boolean;
    /** Respond to biometric stress levels when adaptive is enabled */
    biometricResponsive?: boolean;
    /** Adjust UI complexity based on stress when adaptive is enabled */
    complexityAdjustment?: boolean;
    /** Require calm state for certain actions when adaptive is enabled */
    requiresCalm?: boolean;
    /** Adapt content based on user patterns when adaptive is enabled */
    contentAdaptation?: boolean;
    /** Provide audio feedback when spatialAudio is enabled */
    audioFeedback?: boolean;
    /** Enable directional audio cues when spatialAudio is enabled */
    directionalCues?: boolean;
    /** Position audio in 3D space when spatialAudio is enabled */
    position?: 'left' | 'center' | 'right' | {
        x: number;
        y: number;
        z: number;
    };
    /** Achievement identifier for tracking when trackAchievements is enabled */
    achievementId?: string;
    /** Context for achievement tracking when trackAchievements is enabled */
    usageContext?: 'onboarding' | 'form' | 'navigation' | 'dashboard' | 'analytics' | 'report' | 'presentation' | 'exploration' | 'advanced' | 'showcase' | string;
    /** Show progress indicators when trackAchievements is enabled */
    progressIndicators?: boolean;
}
export interface NavigationConsciousnessFeatures extends ExtendedConsciousnessFeatures {
    /** Pattern recognition for navigation behavior */
    patternRecognition?: boolean;
    /** Audio navigation cues */
    audioNavigation?: boolean;
}
export interface FormConsciousnessFeatures extends ExtendedConsciousnessFeatures {
    /** Auto-complete based on patterns */
    smartAutoComplete?: boolean;
    /** Validate input in real-time */
    predictiveValidation?: boolean;
    /** Suggest form completions */
    formSuggestions?: boolean;
}
export interface ChartConsciousnessFeatures extends ExtendedConsciousnessFeatures {
    /** Provide chart insights */
    chartInsights?: boolean;
    /** Analyze data patterns */
    patternAnalysis?: boolean;
    /** Focus on data points based on gaze */
    dataPointFocus?: boolean;
}
export interface ModalConsciousnessFeatures extends ExtendedConsciousnessFeatures {
    /** Focus management with eye tracking */
    focusManagement?: boolean;
    /** Audio positioning for modal */
    modalAudioPosition?: boolean;
}
export interface CardConsciousnessFeatures extends ExtendedConsciousnessFeatures {
    /** Focus-aware expansion */
    focusExpansion?: boolean;
    /** Stress-aware simplification */
    stressAware?: boolean;
    /** Simplification mode for high stress */
    simplificationMode?: boolean;
}
export interface ConsciousnessEventHandlers {
    /** Called when predictive analysis completes */
    onPredictiveAnalysis?: (analysis: PredictiveAnalysis) => void;
    /** Called when eye tracking detects gaze */
    onGazeEnter?: (target: Element) => void;
    /** Called when eye tracking loses gaze */
    onGazeExit?: (target: Element) => void;
    /** Called when biometric state changes */
    onBiometricChange?: (state: BiometricState) => void;
    /** Called when spatial audio plays */
    onAudioPlay?: (audioId: string, position?: SpatialPosition) => void;
    /** Called when achievement is unlocked */
    onAchievementUnlocked?: (achievement: Achievement) => void;
    /** Called when consciousness feature state changes */
    onConsciousnessChange?: (feature: string, enabled: boolean) => void;
}
export interface PredictiveAnalysis {
    patterns: UserPattern[];
    insights: Insight[];
    recommendations: string[];
    confidence: number;
    timestamp: number;
}
export interface UserPattern {
    id: string;
    type: 'navigation' | 'interaction' | 'temporal' | 'behavioral';
    frequency: number;
    lastOccurrence: number;
    confidence: number;
    metadata: Record<string, any>;
}
export interface Insight {
    id: string;
    type: 'usage' | 'performance' | 'preference' | 'optimization';
    description: string;
    impact: 'low' | 'medium' | 'high';
    actionable: boolean;
    metadata: Record<string, any>;
}
export interface BiometricState {
    stressLevel: number;
    cognitiveLoad: number;
    attention: number;
    confidence: number;
    timestamp: number;
}
export interface SpatialPosition {
    x: number;
    y: number;
    z: number;
}
export interface Achievement {
    id: string;
    name: string;
    description: string;
    category: string;
    unlocked: boolean;
    progress: number;
    timestamp?: number;
    metadata: Record<string, any>;
}
export interface GazeData {
    x: number;
    y: number;
    confidence: number;
    timestamp: number;
    target?: Element;
}
export interface ConsciousnessConfig {
    /** Global enable/disable for all consciousness features */
    enabled: boolean;
    /** Individual feature toggles */
    features: {
        predictive: boolean;
        eyeTracking: boolean;
        adaptive: boolean;
        spatialAudio: boolean;
        achievements: boolean;
    };
    /** Performance settings */
    performance: {
        eyeTrackingFPS: number;
        biometricUpdateInterval: number;
        predictiveAnalysisDelay: number;
        spatialAudioUpdateRate: number;
    };
    /** Privacy settings */
    privacy: {
        dataRetentionDays: number;
        anonymizeData: boolean;
        shareAnalytics: boolean;
        requireConsent: boolean;
    };
    /** Accessibility settings */
    accessibility: {
        respectReducedMotion: boolean;
        respectHighContrast: boolean;
        provideAudioAlternatives: boolean;
        announceStateChanges: boolean;
    };
}
export interface PredictiveEngineConfig {
    enabled: boolean;
    analysisDelay?: number;
    maxPatterns?: number;
    confidenceThreshold?: number;
}
export interface EyeTrackingConfig {
    enabled: boolean;
    updateRate?: number;
    gazeThreshold?: number;
    dwellTime?: number;
    calibrationRequired?: boolean;
}
export interface BiometricAdaptationConfig {
    enabled: boolean;
    updateInterval?: number;
    stressThreshold?: number;
    cognitiveLoadThreshold?: number;
    adaptationSensitivity?: number;
}
export interface SpatialAudioConfig {
    enabled: boolean;
    updateRate?: number;
    maxSources?: number;
    falloffDistance?: number;
    volume?: number;
}
export interface AchievementSystemConfig {
    enabled: boolean;
    categories?: string[];
    persistProgress?: boolean;
    showNotifications?: boolean;
    trackingGranularity?: 'basic' | 'detailed' | 'comprehensive';
}
export interface WithConsciousnessProps {
    /** Consciousness feature configuration */
    consciousnessFeatures?: ExtendedConsciousnessFeatures;
    /** Consciousness event handlers */
    consciousnessHandlers?: ConsciousnessEventHandlers;
    /** Override global consciousness config */
    consciousnessConfig?: Partial<ConsciousnessConfig>;
    /** Disable all consciousness features for this component */
    disableConsciousness?: boolean;
}
export interface WithNavigationConsciousnessProps extends WithConsciousnessProps {
    consciousnessFeatures?: NavigationConsciousnessFeatures;
}
export interface WithFormConsciousnessProps extends WithConsciousnessProps {
    consciousnessFeatures?: FormConsciousnessFeatures;
}
export interface WithChartConsciousnessProps extends WithConsciousnessProps {
    consciousnessFeatures?: ChartConsciousnessFeatures;
}
export interface WithModalConsciousnessProps extends WithConsciousnessProps {
    consciousnessFeatures?: ModalConsciousnessFeatures;
}
export interface WithCardConsciousnessProps extends WithConsciousnessProps {
    consciousnessFeatures?: CardConsciousnessFeatures;
}
export type ConsciousnessVariant<T> = T & WithConsciousnessProps;
export type NavigationConsciousnessVariant<T> = T & WithNavigationConsciousnessProps;
export type FormConsciousnessVariant<T> = T & WithFormConsciousnessProps;
export type ChartConsciousnessVariant<T> = T & WithChartConsciousnessProps;
export type ModalConsciousnessVariant<T> = T & WithModalConsciousnessProps;
export type CardConsciousnessVariant<T> = T & WithCardConsciousnessProps;
export declare const DEFAULT_CONSCIOUSNESS_CONFIG: ConsciousnessConfig;
export declare const DEFAULT_PREDICTIVE_CONFIG: PredictiveEngineConfig;
export declare const DEFAULT_EYE_TRACKING_CONFIG: EyeTrackingConfig;
export declare const DEFAULT_BIOMETRIC_CONFIG: BiometricAdaptationConfig;
export declare const DEFAULT_SPATIAL_AUDIO_CONFIG: SpatialAudioConfig;
export declare const DEFAULT_ACHIEVEMENT_CONFIG: AchievementSystemConfig;
export declare const CONSCIOUSNESS_COMPONENT_VARIANTS: {
    readonly Conscious: "Conscious";
    readonly Predictive: "Predictive";
    readonly Adaptive: "Adaptive";
    readonly Immersive: "Immersive";
    readonly EyeTracking: "EyeTracking";
    readonly Biometric: "Biometric";
    readonly SpatialAudio: "SpatialAudio";
    readonly Achievement: "Achievement";
};
export type ConsciousnessFeatureFlag = keyof BaseConsciousnessFeatures;
export declare const hasConsciousnessFeatures: (features?: ExtendedConsciousnessFeatures) => boolean;
export declare const getEnabledConsciousnessFeatures: (features?: ExtendedConsciousnessFeatures) => ConsciousnessFeatureFlag[];
export declare const createConsciousnessFeatures: (features?: Partial<ExtendedConsciousnessFeatures>) => ExtendedConsciousnessFeatures;
export declare const isNavigationConsciousnessFeatures: (features: any) => features is NavigationConsciousnessFeatures;
export declare const isFormConsciousnessFeatures: (features: any) => features is FormConsciousnessFeatures;
export declare const isChartConsciousnessFeatures: (features: any) => features is ChartConsciousnessFeatures;
export declare class ConsciousnessError extends Error {
    readonly feature: ConsciousnessFeatureFlag;
    readonly code: string;
    constructor(message: string, feature: ConsciousnessFeatureFlag, code: string);
}
export declare class ConsciousnessPermissionError extends ConsciousnessError {
    constructor(feature: ConsciousnessFeatureFlag);
}
export declare class ConsciousnessUnsupportedError extends ConsciousnessError {
    constructor(feature: ConsciousnessFeatureFlag);
}
export interface ConsciousnessAnalytics {
    sessionId: string;
    userId?: string;
    features: ConsciousnessFeatureFlag[];
    interactions: ConsciousnessInteraction[];
    performance: ConsciousnessPerformanceMetrics;
    errors: ConsciousnessError[];
}
export interface ConsciousnessInteraction {
    id: string;
    type: 'gaze' | 'biometric' | 'predictive' | 'spatial' | 'achievement';
    componentType: string;
    timestamp: number;
    duration?: number;
    metadata: Record<string, any>;
}
export interface ConsciousnessPerformanceMetrics {
    initialization: number;
    averageResponseTime: number;
    memoryUsage: number;
    errorRate: number;
    featureUsage: Record<ConsciousnessFeatureFlag, number>;
}
//# sourceMappingURL=consciousness.d.ts.map