import { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart } from './eval-hyperscript';
import { hyperscript, config } from '../api/lokascript-api';
import type { RuntimeHooks } from '../types/hooks';
import { defaultAttributeProcessor } from '../dom/attribute-processor';
import { tailwindExtension } from '../extensions/tailwind';
import { Parser } from '../parser/parser';
import { Runtime } from '../runtime/runtime';
import { tokenize } from '../parser/tokenizer';
import { debug, debugControl } from '../utils/debug';
import { styleBatcher, ObjectPool } from '../utils/performance';
import { enableDebugEvents, disableDebugEvents, isDebugEnabled, getDebugStats, resetDebugStats, getEventHistory, replayEvents } from '../utils/debug-events';
import { createSemanticAnalyzer, parse as semanticParse, translate, render, toExplicit, fromExplicit } from '@lokascript/semantic';
import type { CompileResult, NewCompileOptions } from '../api/hyperscript-api';
interface LokaScriptBrowserAPI {
    evalHyperScript: typeof evalHyperScript;
    evalHyperScriptAsync: typeof evalHyperScriptAsync;
    evalHyperScriptSmart: typeof evalHyperScriptSmart;
    tailwindExtension: typeof tailwindExtension;
    compile: (code: string, options?: NewCompileOptions) => CompileResult;
    compileSync: (code: string, options?: NewCompileOptions) => CompileResult;
    compileMultilingual: (code: string, language: string) => Promise<CompileResult>;
    execute: typeof hyperscript.execute;
    run: (code: string, context?: any) => Promise<unknown>;
    createContext: typeof hyperscript.createContext;
    createRuntime: typeof hyperscript.createRuntime;
    processNode: (element: Element | Document) => Promise<void>;
    process: (element: Element | Document) => Promise<void>;
    Parser: typeof Parser;
    Runtime: typeof Runtime;
    tokenize: typeof tokenize;
    attributeProcessor: typeof defaultAttributeProcessor;
    debug: typeof debug;
    debugControl: typeof debugControl;
    styleBatcher: typeof styleBatcher;
    ObjectPool: typeof ObjectPool;
    semantic: {
        createAnalyzer: typeof createSemanticAnalyzer;
        parse: typeof semanticParse;
        translate: typeof translate;
        render: typeof render;
        toExplicit: typeof toExplicit;
        fromExplicit: typeof fromExplicit;
        supportedLanguages: string[];
    };
    semanticDebug: {
        enable: typeof enableDebugEvents;
        disable: typeof disableDebugEvents;
        isEnabled: typeof isDebugEnabled;
        getStats: typeof getDebugStats;
        resetStats: typeof resetDebugStats;
        getEventHistory: typeof getEventHistory;
        replayEvents: typeof replayEvents;
    };
    config: typeof config;
    registerHooks: (name: string, hooks: RuntimeHooks) => void;
    unregisterHooks: (name: string) => boolean;
    getRegisteredHooks: () => string[];
}
declare global {
    interface Window {
        lokascript: LokaScriptBrowserAPI;
        hyperfixi: LokaScriptBrowserAPI;
        evalHyperScript: typeof evalHyperScript;
        evalHyperScriptAsync: typeof evalHyperScriptAsync;
        evalHyperScriptSmart: typeof evalHyperScriptSmart;
    }
}
declare const lokascriptAPI: {
    evalHyperScript: typeof evalHyperScript;
    evalHyperScriptAsync: typeof evalHyperScriptAsync;
    evalHyperScriptSmart: typeof evalHyperScriptSmart;
    evaluate: typeof evalHyperScript;
    compile: (code: string, options?: NewCompileOptions) => CompileResult;
    compileSync: (code: string, options?: NewCompileOptions) => CompileResult;
    compileMultilingual: (code: string, language: string) => Promise<CompileResult>;
    execute: (ast: import("..").ASTNode, context?: import("..").ExecutionContext) => Promise<unknown>;
    run: (code: string, context?: any) => Promise<unknown>;
    createContext: (element?: HTMLElement | null, parent?: import("..").ExecutionContext) => import("..").ExecutionContext;
    createRuntime: (options?: import("../runtime/runtime").RuntimeOptions) => Runtime;
    Parser: typeof Parser;
    Runtime: typeof Runtime;
    tokenize: typeof tokenize;
    processNode: (element: Element | Document) => Promise<void>;
    process: (element: Element | Document) => Promise<void>;
    attributeProcessor: import("../dom/attribute-processor").AttributeProcessor;
    tailwindExtension: import("../extensions/tailwind").TailwindExtension;
    styleBatcher: import("../utils/performance").StyleBatcher;
    ObjectPool: typeof ObjectPool;
    debug: {
        command: (...args: any[]) => void;
        event: (...args: any[]) => void;
        parse: (...args: any[]) => void;
        expr: (...args: any[]) => void;
        expressions: (...args: any[]) => void;
        style: (...args: any[]) => void;
        runtime: (...args: any[]) => void;
        loop: (...args: any[]) => void;
        async: (...args: any[]) => void;
    };
    debugControl: {
        enable(): void;
        disable(): void;
        isEnabled(): boolean;
        status(): {
            enabled: boolean;
            source: string;
        };
    };
    semantic: {
        createAnalyzer: typeof createSemanticAnalyzer;
        parse: typeof semanticParse;
        translate: typeof translate;
        render: typeof render;
        toExplicit: typeof toExplicit;
        fromExplicit: typeof fromExplicit;
        supportedLanguages: string[];
    };
    semanticDebug: {
        enable: typeof enableDebugEvents;
        disable: typeof disableDebugEvents;
        isEnabled: typeof isDebugEnabled;
        getStats: typeof getDebugStats;
        resetStats: typeof resetDebugStats;
        getEventHistory: typeof getEventHistory;
        replayEvents: typeof replayEvents;
    };
    config: import("../api/hyperscript-api").HyperscriptConfig;
    registerHooks: (name: string, hooks: RuntimeHooks) => void;
    unregisterHooks: (name: string) => boolean;
    getRegisteredHooks: () => string[];
    version: string;
};
export default lokascriptAPI;
//# sourceMappingURL=browser-bundle.d.ts.map