wifi-densepose/vendor/sublinear-time-solver/dist/mcp/tools/index.d.ts

/**
 * MCP Tools Export
 *
 * This module exports all MCP tool classes and provides
 * a consolidated tool list for the MCP server
 */
import { SolverTools } from './solver.js';
import { MatrixTools } from './matrix.js';
import { EmergenceTools } from './emergence-tools.js';
import { ConsciousnessTools } from './consciousness.js';
import { SchedulerTools } from './scheduler.js';
import { PsychoSymbolicTools } from './psycho-symbolic.js';
export { SolverTools } from './solver.js';
export { MatrixTools } from './matrix.js';
export { EmergenceTools } from './emergence-tools.js';
export { ConsciousnessTools } from './consciousness.js';
export { SchedulerTools } from './scheduler.js';
export { PsychoSymbolicTools } from './psycho-symbolic.js';
export { WasmSublinearSolverTools } from './wasm-sublinear-solver.js';
export { temporalAttractorHandlers } from './temporal-attractor-handlers.js';
export declare const solverTools: any;
export declare const matrixTools: any;
export declare const emergenceTools: any;
export declare const consciousnessTools: any;
export declare const schedulerTools: any;
export declare const psychoSymbolicTools: any;
export { temporalAttractorTools } from './temporal-attractor.js';
export declare const allTools: any[];
declare const _default: {
    solver: SolverTools;
    matrix: MatrixTools;
    emergence: EmergenceTools;
    consciousness: ConsciousnessTools;
    scheduler: SchedulerTools;
    psychoSymbolic: PsychoSymbolicTools;
    temporalAttractor: {
        chaos_analyze: (args: any) => Promise<{
            lambda: any;
            is_chaotic: any;
            chaos_level: any;
            lyapunov_time: any;
            doubling_time: any;
            safe_prediction_steps: any;
            pairs_found: any;
            interpretation: string;
        }>;
        temporal_delay_embed: (args: any) => Promise<{
            original_length: any;
            embedded_vectors: number;
            embedding_dim: any;
            tau: any;
            data: any;
        }>;
        temporal_predict: (args: any) => Promise<{
            initialized: boolean;
            reservoir_size: any;
            training_complete?: undefined;
            mse?: undefined;
            n_samples?: undefined;
            input?: undefined;
            prediction?: undefined;
            trajectory?: undefined;
            n_steps?: undefined;
        } | {
            training_complete: boolean;
            mse: any;
            n_samples: any;
            initialized?: undefined;
            reservoir_size?: undefined;
            input?: undefined;
            prediction?: undefined;
            trajectory?: undefined;
            n_steps?: undefined;
        } | {
            input: any;
            prediction: any;
            initialized?: undefined;
            reservoir_size?: undefined;
            training_complete?: undefined;
            mse?: undefined;
            n_samples?: undefined;
            trajectory?: undefined;
            n_steps?: undefined;
        } | {
            input: any;
            trajectory: any;
            n_steps: any;
            initialized?: undefined;
            reservoir_size?: undefined;
            training_complete?: undefined;
            mse?: undefined;
            n_samples?: undefined;
            prediction?: undefined;
        }>;
        temporal_fractal_dimension: (args: any) => Promise<{
            fractal_dimension: any;
            interpretation: string;
        }>;
        temporal_regime_changes: (args: any) => Promise<{
            n_windows: any;
            lyapunov_values: any;
            changes_detected: boolean;
            max_lambda: number;
            min_lambda: number;
            variance: number;
        }>;
        temporal_generate_attractor: (args: any) => Promise<{
            system: any;
            n_points: any;
            dimensions: any;
            dt: any;
            data: any;
        }>;
        temporal_interpret_chaos: (args: any) => Promise<any>;
        temporal_recommend_parameters: (args: any) => Promise<any>;
        temporal_attractor_pullback: (args: any) => Promise<{
            ensemble_size: any;
            evolution_time: any;
            snapshots: any[];
            drift: any[];
            convergence_rate: number;
        }>;
        temporal_kaplan_yorke_dimension: (args: any) => Promise<{
            kaplan_yorke_dimension: number;
            lyapunov_spectrum: any;
            interpretation: string;
        }>;
    };
    SolverTools: typeof SolverTools;
    MatrixTools: typeof MatrixTools;
    EmergenceTools: typeof EmergenceTools;
    ConsciousnessTools: typeof ConsciousnessTools;
    SchedulerTools: typeof SchedulerTools;
    PsychoSymbolicTools: typeof PsychoSymbolicTools;
    solverTools: any;
    matrixTools: any;
    emergenceTools: any;
    consciousnessTools: any;
    schedulerTools: any;
    psychoSymbolicTools: any;
    allTools: any[];
};
export default _default;