@ebowwa/coder 0.2.1 → 0.7.64

package/dist/interfaces/ui/terminal/tui/useNativeInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNativeInput.d.ts","sourceRoot":"","sources":["../../../../../packages/src/interfaces/ui/terminal/tui/useNativeInput.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAc,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAEnG,UAAU,qBAAqB;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8BAA8B;IAC9B,KAAK,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;CACxC;AAED,UAAU,oBAAoB;IAC5B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,8CAA8C;IAC9C,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,EAC7B,QAAe,EACf,KAAK,GACN,EAAE,qBAAqB,GAAG,oBAAoB,CA2E9C;AAED;;GAEG;AACH,eAAO,MAAM,SAAS;IACpB,kCAAkC;mBACnB,cAAc,GAAG,OAAO;IAIvC,sCAAsC;uBACnB,cAAc,GAAG,OAAO;IAI3C,mCAAmC;oBACnB,cAAc,GAAG,OAAO;IAIxC,mCAAmC;oBACnB,cAAc,GAAG,OAAO;IAIxC,gCAAgC;iBACnB,cAAc,GAAG,OAAO;IAIrC,gDAAgD;qBAC/B,cAAc,GAAG,OAAO;IAIzC,qCAAqC;gBACzB,cAAc,GAAG,OAAO;IAIpC,uCAAuC;kBACzB,cAAc,GAAG,OAAO;IAItC,uCAAuC;kBACzB,cAAc,GAAG,OAAO;IAItC,wCAAwC;mBACzB,cAAc,GAAG,OAAO;IAIvC,oCAAoC;oBACpB,cAAc,GAAG,OAAO;IAIxC,sCAAsC;sBACpB,cAAc,GAAG,OAAO;IAI1C,iCAAiC;kBACnB,cAAc,GAAG,OAAO;IAItC,gCAAgC;iBACnB,cAAc,GAAG,OAAO;IAIrC,+BAA+B;mBAChB,cAAc,GAAG,OAAO;IAIvC,mDAAmD;mBACpC,cAAc,GAAG,OAAO;IAIvC,6CAA6C;mBAC9B,cAAc,GAAG,OAAO;IAIvC,8CAA8C;uBAC3B,cAAc,GAAG,OAAO;IAU3C,iCAAiC;qBAChB,cAAc,GAAG,OAAO;IAIzC,mCAAmC;uBAChB,cAAc,GAAG,OAAO;CAG5C,CAAC;AAEF,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC"}

package/dist/interfaces/ui/terminal/tui/useNativeInput.js

@@ -0,0 +1,188 @@
+/**
+ * Native terminal input hook
+ *
+ * Reads key events from stdin without managing raw mode.
+ * Ink handles raw mode - we just read the key events.
+ *
+ * IMPORTANT: This hook does NOT manage raw mode. Ink does that.
+ * We only read events from stdin via the native module.
+ */
+import { useEffect, useRef, useState } from "react";
+import { loadNative } from "../../../../native/index.js";
+/**
+ * React hook for terminal keyboard input
+ *
+ * Uses native Rust TerminalHandle to read key events from stdin.
+ * Does NOT manage raw mode - let Ink handle that.
+ *
+ * @example
+ * ```tsx
+ * useNativeInput({
+ *   isActive: !isLoading,
+ *   onKey: (event) => {
+ *     if (KeyEvents.isEnter(event)) {
+ *       handleSubmit();
+ *     } else if (KeyEvents.isPrintable(event)) {
+ *       handleChar(event.code);
+ *     }
+ *   },
+ * });
+ * ```
+ */
+export function useNativeInput({ isActive = true, onKey, }) {
+    const [isReady, setIsReady] = useState(false);
+    const [error, setError] = useState(null);
+    const onKeyRef = useRef(onKey);
+    const terminalRef = useRef(null);
+    const runningRef = useRef(false);
+    // Keep callback ref updated
+    useEffect(() => {
+        onKeyRef.current = onKey;
+    }, [onKey]);
+    // Initialize terminal and start polling loop
+    useEffect(() => {
+        if (!isActive) {
+            runningRef.current = false;
+            setIsReady(false);
+            return;
+        }
+        // Get terminal handle from native module
+        const native = loadNative();
+        let terminal;
+        try {
+            terminal = native.create_terminal();
+            terminalRef.current = terminal;
+        }
+        catch (e) {
+            const err = e instanceof Error ? e : new Error(String(e));
+            setError(err);
+            return;
+        }
+        // DON'T enter raw mode - Ink handles that
+        // Just mark as ready and start polling
+        setIsReady(true);
+        runningRef.current = true;
+        // Polling loop using setImmediate-like behavior
+        let timeoutId = null;
+        const poll = () => {
+            if (!runningRef.current)
+                return;
+            try {
+                // Poll with 16ms timeout (60fps) for responsive input
+                // Use non-blocking read - returns null if no event available
+                const event = terminal.pollEvent(16);
+                if (event) {
+                    onKeyRef.current(event);
+                }
+            }
+            catch {
+                // Ignore polling errors
+            }
+            // Continue polling with a small delay to prevent tight loop
+            if (runningRef.current) {
+                timeoutId = setTimeout(poll, 16);
+            }
+        };
+        // Start polling
+        poll();
+        // Cleanup: stop polling (no raw mode to exit - Ink handles that)
+        return () => {
+            runningRef.current = false;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            terminalRef.current = null;
+            setIsReady(false);
+        };
+    }, [isActive]);
+    return { isReady, error };
+}
+/**
+ * Key event helper functions
+ */
+export const KeyEvents = {
+    /** Check if event is Enter key */
+    isEnter(event) {
+        return event.code === "enter" && event.kind === "press";
+    },
+    /** Check if event is Backspace key */
+    isBackspace(event) {
+        return event.code === "backspace" && event.kind === "press";
+    },
+    /** Check if event is Delete key */
+    isDelete(event) {
+        return event.code === "delete" && event.kind === "press";
+    },
+    /** Check if event is Escape key */
+    isEscape(event) {
+        return event.code === "escape" && event.kind === "press";
+    },
+    /** Check if event is Tab key */
+    isTab(event) {
+        return event.code === "tab" && event.kind === "press";
+    },
+    /** Check if event is BackTab (Shift+Tab) key */
+    isBackTab(event) {
+        return event.code === "backtab" && event.kind === "press";
+    },
+    /** Check if event is Arrow Up key */
+    isUp(event) {
+        return event.code === "up" && event.kind === "press";
+    },
+    /** Check if event is Arrow Down key */
+    isDown(event) {
+        return event.code === "down" && event.kind === "press";
+    },
+    /** Check if event is Arrow Left key */
+    isLeft(event) {
+        return event.code === "left" && event.kind === "press";
+    },
+    /** Check if event is Arrow Right key */
+    isRight(event) {
+        return event.code === "right" && event.kind === "press";
+    },
+    /** Check if event is Page Up key */
+    isPageUp(event) {
+        return event.code === "pageup" && event.kind === "press";
+    },
+    /** Check if event is Page Down key */
+    isPageDown(event) {
+        return event.code === "pagedown" && event.kind === "press";
+    },
+    /** Check if event is Home key */
+    isHome(event) {
+        return event.code === "home" && event.kind === "press";
+    },
+    /** Check if event is End key */
+    isEnd(event) {
+        return event.code === "end" && event.kind === "press";
+    },
+    /** Check if event is Ctrl+C */
+    isCtrlC(event) {
+        return event.code === "c" && event.ctrl && event.kind === "press";
+    },
+    /** Check if event is Ctrl+A (beginning of line) */
+    isCtrlA(event) {
+        return event.code === "a" && event.ctrl && event.kind === "press";
+    },
+    /** Check if event is Ctrl+E (end of line) */
+    isCtrlE(event) {
+        return event.code === "e" && event.ctrl && event.kind === "press";
+    },
+    /** Check if event is a printable character */
+    isPrintable(event) {
+        return (!event.is_special &&
+            !event.ctrl &&
+            !event.alt &&
+            event.code.length === 1 &&
+            event.kind === "press");
+    },
+    /** Check if event is Shift+Up */
+    isShiftUp(event) {
+        return event.code === "up" && event.shift && event.kind === "press";
+    },
+    /** Check if event is Shift+Down */
+    isShiftDown(event) {
+        return event.code === "down" && event.shift && event.kind === "press";
+    },
+};

package/dist/native/index.d.ts

@@ -0,0 +1,480 @@
+/**
+ * Native module loader
+ * Loads Rust-compiled native modules for performance-critical operations
+ */
+export interface HighlightResult {
+    /** ANSI-colored text (for terminal display) */
+    html: string;
+    /** Theme used for highlighting */
+    theme: string;
+}
+export interface HighlightDiffResult {
+    /** ANSI-colored diff output */
+    output: string;
+    /** Number of added lines */
+    additions: number;
+    /** Number of deleted lines */
+    deletions: number;
+    /** Number of hunks */
+    hunks: number;
+}
+export interface DiffOptions {
+    /** File path to display in header */
+    file_path?: string;
+    /** Number of context lines around changes (default: 3) */
+    context_lines?: number;
+}
+/** A single edit operation for multi-file editing */
+export interface MultiEditEntry {
+    /** File path to edit (absolute path) */
+    filePath: string;
+    /** String to find and replace */
+    oldString: string;
+    /** Replacement string */
+    newString: string;
+    /** Replace all occurrences (default: false) */
+    replaceAll?: boolean;
+}
+/** Result of an atomic multi-file edit operation */
+export interface MultiEditResult {
+    /** Whether all edits succeeded */
+    success: boolean;
+    /** List of files that were modified */
+    filesModified: string[];
+    /** Total number of string replacements made */
+    totalReplacements: number;
+    /** Error message if operation failed */
+    error?: string;
+    /** Whether changes were rolled back due to failure */
+    rolledBack: boolean;
+}
+/** Preview result for a single file */
+export interface MultiEditPreviewEntry {
+    /** File path */
+    filePath: string;
+    /** Number of replacements that would be made */
+    replacementCount: number;
+}
+/** OHLCV candlestick data */
+export interface OHLCV {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+/** AMM state for constant-product AMMs */
+export interface AMMState {
+    pool_yes: number;
+    pool_no: number;
+    k: number;
+    fee: number;
+    price_yes: number;
+    price_no: number;
+}
+/** AMM cost calculation result */
+export interface AMMCostResult {
+    cost: number;
+    avg_price: number;
+}
+/** AMM price impact result */
+export interface AMMPriceImpactResult {
+    price_before: number;
+    price_after: number;
+    price_impact: number;
+    slippage: number;
+}
+/** LMSR price result */
+export interface LMSRPriceResult {
+    yes_price: number;
+    no_price: number;
+    spread: number;
+}
+/** Arbitrage detection result */
+export interface ArbitrageResult {
+    has_arbitrage: boolean;
+    yes_price: number;
+    no_price: number;
+    total: number;
+    profit_per_share: number;
+}
+/** Odds conversion result */
+export interface OddsConversion {
+    probability: number;
+    decimal_odds: number;
+    american_odds: number;
+}
+/** Value at Risk result */
+export interface VaRResult {
+    var: number;
+    cvar: number;
+    confidence_level: number;
+}
+/** Drawdown analysis result */
+export interface DrawdownResult {
+    max_drawdown: number;
+    max_duration: number;
+    current_drawdown: number;
+    recovery_factor: number;
+}
+/** Sharpe ratio result */
+export interface SharpeResult {
+    sharpe_ratio: number;
+    annualized_sharpe: number;
+    risk_free_rate: number;
+    avg_return: number;
+    std_dev: number;
+}
+/** Native key event from terminal */
+export interface NativeKeyEvent {
+    /** The key code (character or special key name) */
+    code: string;
+    /** Whether this is a special key (arrow, function, etc.) */
+    is_special: boolean;
+    /** Ctrl modifier */
+    ctrl: boolean;
+    /** Alt/Meta modifier */
+    alt: boolean;
+    /** Shift modifier */
+    shift: boolean;
+    /** Event kind: "press", "release", "repeat" */
+    kind: "press" | "release" | "repeat";
+}
+/** Terminal handle for raw mode input */
+export interface TerminalHandle {
+    /** Enter raw terminal mode */
+    enterRawMode(): void;
+    /** Exit raw terminal mode */
+    exitRawMode(): void;
+    /** Check if in raw mode (getter) */
+    readonly isRawMode: boolean;
+    /** Poll for a key event (non-blocking), returns null if no event */
+    pollEvent(timeoutMs?: number): NativeKeyEvent | null;
+    /** Read next key event (blocking, async) */
+    readEvent(): Promise<NativeKeyEvent>;
+}
+/** Message for display in the native TUI */
+export interface TuiMessage {
+    id: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp?: number;
+    subType?: string;
+    toolName?: string;
+    isError?: boolean;
+}
+/** TUI state for rendering */
+export interface TuiState {
+    messages: TuiMessage[];
+    inputValue: string;
+    cursorPos: number;
+    isLoading: boolean;
+    spinnerFrame: number;
+    model: string;
+    tokensUsed: number;
+    permissionMode: string;
+    streamingText: string;
+    scrollOffset: number;
+    contextWarning?: string;
+}
+/** Result of handling input in native TUI */
+export interface InputResult {
+    submitted: boolean;
+    text?: string;
+    exitRequested: boolean;
+    command?: string;
+    scrollUp: boolean;
+    scrollDown: boolean;
+    inputValue: string;
+    cursorPos: number;
+    historyNavigated: boolean;
+    historyDirection: number;
+}
+/** Native TUI handle from Rust */
+export interface NativeTuiHandle {
+    init(): void;
+    cleanup(): void;
+    render(state: TuiState): void;
+    pollInput(state: TuiState, timeoutMs?: number): InputResult;
+    addToHistory(input: string): void;
+}
+export interface NativeModule {
+    /** Syntax highlight code with ANSI escape codes */
+    highlight_code: (code: string, language: string) => HighlightResult;
+    /** Highlight markdown with nested code block syntax highlighting */
+    highlight_markdown: (markdown: string) => HighlightResult;
+    /** Highlight a diff with ANSI colors */
+    highlight_diff: (oldText: string, newText: string, options?: DiffOptions) => HighlightDiffResult;
+    search_files: (pattern: string, path: string, options: {
+        case_insensitive?: boolean;
+        hidden?: boolean;
+        glob?: string;
+        max_results?: number;
+    }) => {
+        matches: Array<{
+            file_path: string;
+            line_number: number;
+            column: number;
+            line_content: string;
+            match_text: string;
+        }>;
+        total_count: number;
+        files_searched: number;
+    };
+    count_tokens: (text: string) => number;
+    calculate_diff: (oldText: string, newText: string) => Array<{
+        oldStart: number;
+        oldLines: number;
+        newStart: number;
+        newLines: number;
+        content: string;
+    }>;
+    compact_content: (content: string, maxTokens: number, strategy?: "truncate" | "summarize" | "extract") => string;
+    count_tool_use: (messages: Array<{
+        role: string;
+        tool_use?: Array<{
+            name: string;
+            input?: any;
+        }>;
+        tool_result?: Array<any>;
+    }>) => Record<string, number>;
+    find_tool_pairs: (messages: Array<{
+        role: string;
+        tool_use?: Array<{
+            name: string;
+            input?: any;
+        }>;
+        tool_result?: Array<any>;
+    }>, window_size: number) => Record<string, Record<string, number>>;
+    find_common_patterns: (messages: Array<{
+        role: string;
+        tool_use?: Array<{
+            name: string;
+            input?: any;
+        }>;
+        tool_result?: Array<any>;
+    }>) => Array<{
+        tools: [string, string];
+        count: number;
+        percentage: number;
+    }>;
+    /** Validate multi-file edits without applying them */
+    validate_multi_edits: (edits: MultiEditEntry[]) => string[];
+    /** Preview what edits would be applied without making changes */
+    preview_multi_edits: (edits: MultiEditEntry[]) => MultiEditPreviewEntry[];
+    /** Apply multiple file edits atomically with rollback on failure */
+    apply_multi_edits: (edits: MultiEditEntry[]) => MultiEditResult;
+    /** Get library version */
+    quant_version: () => string;
+    quant_ohlcv_new: (timestamp: bigint, open: number, high: number, low: number, close: number, volume: number) => string;
+    quant_amm_new: (poolYes: number, poolNo: number, fee: number) => string;
+    quant_amm_calculate_cost: (poolYes: number, poolNo: number, buyYes: boolean, shares: number) => string;
+    quant_amm_price_impact: (poolYes: number, poolNo: number, buyYes: boolean, shares: number) => string;
+    quant_lmsr_price: (yesShares: number, noShares: number, b: number) => string;
+    quant_lmsr_cost: (yesShares: number, noShares: number, b: number, buyYes: boolean, shares: number) => string;
+    quant_detect_arbitrage: (yesPrice: number, noPrice: number) => string;
+    quant_convert_odds: (value: number, fromType: number) => string;
+    quant_mean: (data: Float64Array) => number;
+    quant_std_dev: (data: Float64Array) => number;
+    quant_variance: (data: Float64Array) => number;
+    quant_correlation: (x: Float64Array, y: Float64Array) => number;
+    /** Classify an operation into an action type */
+    classify_operation: (operation: string, domain: string, target?: string | null, reasoning?: string | null) => any;
+    /** Get all supported action types */
+    get_action_types: () => string[];
+    /** Get risk levels for all action types */
+    get_action_risk_levels: () => Array<{
+        actionType: string;
+        riskLevel: number;
+    }>;
+    /** Create a deny-all policy */
+    create_deny_all_policy: () => any;
+    /** Create an observe-only policy */
+    create_observe_only_policy: () => any;
+    /** Create a transfer approval policy */
+    create_transfer_approval_policy: () => any;
+    /** Generate a new Ed25519 keypair for signing intents */
+    cs_generate_keypair: () => {
+        privateKey: string;
+        publicKey: string;
+    };
+    /** Sign an agent intent with a private key */
+    cs_sign_intent: (intent: any, privateKey: string) => any;
+    /** Verify an intent's signature */
+    cs_verify_intent: (intent: any) => any;
+    /** Hash an intent for comparison */
+    cs_hash_intent: (intent: any) => string;
+    /** Check if two intents are equivalent */
+    cs_intents_equivalent: (intent1: any, intent2: any) => boolean;
+    /** Score how well an action aligns with an intent */
+    cs_score_alignment: (action: any, intent: any) => any;
+    /** Batch score multiple actions against an intent */
+    cs_batch_score_alignment: (actions: any[], intent: any) => any[];
+    /** Check if any action in a sequence would violate intent */
+    cs_check_sequence_violations: (actions: any[], intent: any) => number[];
+    /** Load intent from a JSON file */
+    cs_load_intent: (path: string) => any;
+    /** Save intent to a JSON file */
+    cs_save_intent: (intent: any, path: string) => void;
+    /** Parse intent from JSON string */
+    cs_parse_intent: (json: string) => any;
+    /** Serialize intent to JSON string */
+    cs_serialize_intent: (intent: any) => string;
+    /** Validate intent structure */
+    cs_validate_intent: (intent: any) => any;
+    /** Create a default data collector intent */
+    cs_create_data_collector_intent: (name: string, description: string) => any;
+    /** Merge two intents (child overrides parent) */
+    cs_merge_intents: (base: any, override: any) => any;
+    /** Analyze behavior for signs of intent corruption */
+    cs_analyze_corruption: (snapshot: any, intent: any) => any;
+    /** Detect behavioral drift between two snapshots */
+    cs_detect_drift: (baseline: any, current: any) => any;
+    /** Create an empty behavior snapshot */
+    cs_create_empty_snapshot: () => any;
+    /** Update a snapshot with a new action result */
+    cs_update_snapshot: (snapshot: any, action: any, alignment: any) => any;
+    /** Classify data based on content and source */
+    classify_data: (content: string, source: string, tags: string[]) => any;
+    /** Check if content contains sensitive data */
+    contains_sensitive_data: (content: string) => boolean;
+    /** Redact sensitive content */
+    redact_sensitive: (content: string, replacement?: string | null) => string;
+    /** Get sensitivity levels */
+    get_sensitivity_levels: () => Array<{
+        name: string;
+        value: number;
+        description: string;
+    }>;
+    /** Get data categories */
+    get_data_categories: () => Array<{
+        name: string;
+        description: string;
+    }>;
+    /** Create a flow policy engine */
+    create_flow_policy_engine: () => any;
+    /** Create an allow-all flow policy */
+    create_allow_all_flow_policy: () => any;
+    /** Create a deny-all flow policy */
+    create_deny_all_flow_policy: () => any;
+    /** Create a strict flow policy */
+    create_strict_flow_policy: () => any;
+    /** Create a flow tracker */
+    create_flow_tracker: () => any;
+    /** Create a leak prevention engine */
+    create_leak_prevention: () => any;
+    /** Check content for leaks */
+    check_for_leaks: (content: string, channel: string) => any;
+    /** Sanitize content */
+    sanitize_content: (content: string) => string;
+    /** Create a taint tracker */
+    create_taint_tracker: () => any;
+    /** Create a terminal handle for raw mode input */
+    create_terminal: () => TerminalHandle;
+    /** Create a native TUI handle */
+    create_tui: () => NativeTuiHandle;
+    /** Check if native TUI is available */
+    is_native_tui_available: () => boolean;
+}
+/**
+ * Load the native module
+ */
+export declare function loadNative(): NativeModule;
+/**
+ * Check if native module is available
+ */
+export declare function isNativeAvailable(): boolean;
+export declare const native: NativeModule;
+/**
+ * Syntax highlight code with ANSI escape codes for terminal display
+ * Uses native Rust module if available, falls back to JS implementation
+ */
+export declare function highlight_code(code: string, language: string): HighlightResult;
+/**
+ * Highlight markdown with nested code block syntax highlighting
+ * Parses markdown for code fences and highlights code blocks with their language
+ */
+export declare function highlight_markdown(markdown: string): HighlightResult;
+/**
+ * List all supported languages for syntax highlighting
+ */
+export declare function list_highlight_languages(): string[];
+/**
+ * Highlight a diff with ANSI colors
+ * Uses native Rust module if available, falls back to JS implementation
+ */
+export declare function highlight_diff(oldText: string, newText: string, options?: DiffOptions): HighlightDiffResult;
+/**
+ * Calculate diff hunks with hunk headers for LLM context
+ * Returns structured diff with @@ headers included in content
+ */
+export declare function calculate_diff(oldText: string, newText: string): Array<{
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    content: string;
+}>;
+/**
+ * Validate multi-file edits without applying them
+ * Returns an array of error messages (empty if valid)
+ */
+export declare function validate_multi_edits(edits: MultiEditEntry[]): string[];
+/**
+ * Preview what edits would be applied without making changes
+ * Returns an array of { file_path, replacement_count } for each file
+ */
+export declare function preview_multi_edits(edits: MultiEditEntry[]): MultiEditPreviewEntry[];
+/**
+ * Apply multiple file edits atomically with rollback on failure
+ *
+ * This function:
+ * 1. Validates all edits can be applied (files exist, strings found)
+ * 2. Creates backups of all affected files
+ * 3. Applies all edits
+ * 4. Rolls back on any failure
+ *
+ * @param edits Array of edit operations
+ * @returns Result with success status and list of modified files
+ */
+export declare function apply_multi_edits(edits: MultiEditEntry[]): MultiEditResult;
+/**
+ * Quant module interface for financial calculations
+ * Loads from @ebowwa/quant-rust native library
+ */
+interface QuantModule {
+    quant_version: () => string;
+    quant_last_error: () => string;
+    quant_clear_error: () => void;
+    quant_ohlcv_new: (timestamp: bigint, open: number, high: number, low: number, close: number, volume: number) => string;
+    quant_amm_new: (poolYes: number, poolNo: number, fee: number) => string;
+    quant_amm_calculate_cost: (poolYes: number, poolNo: number, buyYes: boolean, shares: number) => string;
+    quant_amm_price_impact: (poolYes: number, poolNo: number, buyYes: boolean, shares: number) => string;
+    quant_lmsr_price: (yesShares: number, noShares: number, b: number) => string;
+    quant_lmsr_cost: (yesShares: number, noShares: number, b: number, buyYes: boolean, shares: number) => string;
+    quant_detect_arbitrage: (yesPrice: number, noPrice: number) => string;
+    quant_convert_odds: (value: number, fromType: number) => string;
+    quant_mean: (ptr: number, len: number) => number;
+    quant_std_dev: (ptr: number, len: number) => number;
+    quant_variance: (ptr: number, len: number) => number;
+    quant_correlation: (ptrX: number, ptrY: number, len: number) => number;
+    quant_free_string: (ptr: number) => void;
+}
+export declare const quant: QuantModule | null;
+export declare function quantVersion(): string;
+export declare function isQuantAvailable(): boolean;
+export declare function createOHLCV(timestamp: number, open: number, high: number, low: number, close: number, volume: number): OHLCV;
+export declare function createAMM(poolYes: number, poolNo: number, fee: number): AMMState;
+export declare function ammCalculateCost(poolYes: number, poolNo: number, outcome: "yes" | "no" | boolean, shares: number): number;
+export declare function ammPriceImpact(poolYes: number, poolNo: number, outcome: "yes" | "no" | boolean, shares: number): AMMPriceImpactResult;
+export declare function lmsrPrice(yesShares: number, noShares: number, b: number): LMSRPriceResult;
+export declare function lmsrCost(yesShares: number, noShares: number, b: number, outcome: "yes" | "no" | boolean, shares: number): AMMCostResult;
+export declare function detectArbitrage(yesPrice: number, noPrice: number): ArbitrageResult;
+export declare function convertOdds(value: number, fromType: "probability" | "decimal" | "american"): OddsConversion;
+export declare function quantMean(data: number[]): number;
+export declare function quantStdDev(data: number[]): number;
+export declare function quantVariance(data: number[]): number;
+export declare function quantCorrelation(x: number[], y: number[]): number;
+export {};
+//# sourceMappingURL=index.d.ts.map