import type { MagicContextPluginConfig } from "../../config";
import type { LiveSessionState } from "../../hooks/magic-context/live-session-state";
import type { RustModeModuleClient } from "../../hooks/magic-context/rust-mode-transform";
import type { PluginContext } from "../types";
/**
 * Map the full plugin config down to the per-session hook config. Pure and
 * exported so it can be unit-tested directly — without a module-level
 * `mock.module` of the hooks barrel, which in Bun leaks process-globally across
 * test files (mock.restore() does not undo it) and corrupts sibling suites that
 * import the real hook shape.
 */
export declare function buildMagicContextHookConfig(pluginConfig: MagicContextPluginConfig): {
    protected_tags: number;
    execute_threshold_percentage: number | {
        [modelKey: string]: number;
        default: number;
    };
    disabled_hooks?: string[];
    command?: Record<string, {
        template: string;
        description?: string;
        agent?: string;
        model?: string;
        subtask?: boolean;
    }>;
    enabled: boolean;
    transform_mode: "ts" | "rust";
    auto_update?: boolean;
    language?: string;
    historian?: import("../../config/schema").HistorianConfig;
    dreamer?: import("../../config/schema").DreamerConfig;
    cache_ttl: string | {
        default: string;
        [modelKey: string]: string;
    };
    toast_duration_ms?: number;
    execute_threshold_tokens?: {
        default?: number;
        [modelKey: string]: number | undefined;
    };
    clear_reasoning_age: number;
    history_budget_percentage: number;
    historian_timeout_ms: number;
    commit_cluster_trigger: {
        enabled: boolean;
        min_clusters: number;
    };
    sqlite: {
        cache_size_mb: number;
        mmap_size_mb: number;
    };
    system_prompt_injection: {
        enabled: boolean;
        skip_signatures: string[];
    };
    temporal_awareness: boolean;
    keep_subagents: boolean;
    todowrite: {
        enabled: boolean;
        overlay: boolean;
    };
    smart_drops: boolean;
    caveman_text_compression: {
        enabled: boolean;
        min_chars: number;
    };
    embedding: import("../../config/schema").EmbeddingConfig;
    subc?: import("../../config/schema").SubcConfig;
    shadow_embedding?: import("../../config/schema").ShadowEmbeddingConfig;
    memory: {
        enabled: boolean;
        injection_budget_tokens: number;
        auto_promote: boolean;
        retrieval_count_promotion_threshold: number;
        auto_search: {
            enabled: boolean;
            score_threshold: number;
            min_prompt_chars: number;
        };
        git_commit_indexing: {
            enabled: boolean;
            since_days: number;
            max_commits: number;
        };
    };
    shadow_transform: {
        enabled: boolean;
    };
    sidekick?: import("../../config/schema").SidekickConfig;
};
export declare function createSessionHooks(args: {
    ctx: PluginContext;
    pluginConfig: MagicContextPluginConfig;
    liveSessionState: LiveSessionState;
    rustModeModuleClient?: RustModeModuleClient;
}): {
    magicContext: ({
        "experimental.chat.messages.transform": (_input: Record<string, never>, output: {
            messages: unknown[];
        }) => Promise<void>;
        "experimental.chat.system.transform": (input: {
            sessionID?: string;
        }, output: {
            system: string[];
        }) => Promise<void>;
        "experimental.text.complete": (_input: {
            sessionID: string;
            messageID: string;
            partID: string;
        }, output: {
            text: string;
        }) => Promise<void>;
        "chat.message": (input: {
            sessionID?: string;
            variant?: string;
            agent?: string;
            model?: {
                providerID?: string;
                modelID?: string;
            };
        }) => Promise<void>;
        event: (input: {
            event: {
                type: string;
                properties?: unknown;
            };
        }) => Promise<void>;
        "command.execute.before": (input: unknown, output: unknown) => Promise<unknown>;
        "tool.execute.after": (input: unknown, output?: unknown) => Promise<void>;
    } & {
        rustToolBackends?: import("../rust-tool-backends").RustToolBackends;
    }) | null;
    rustToolBackends: import("../rust-tool-backends").RustToolBackends | undefined;
};
export declare function createSessionHooksAsync(args: {
    ctx: PluginContext;
    pluginConfig: MagicContextPluginConfig;
    liveSessionState: LiveSessionState;
    rustModeModuleClient?: RustModeModuleClient;
}): Promise<{
    magicContext: ({
        "experimental.chat.messages.transform": (_input: Record<string, never>, output: {
            messages: unknown[];
        }) => Promise<void>;
        "experimental.chat.system.transform": (input: {
            sessionID?: string;
        }, output: {
            system: string[];
        }) => Promise<void>;
        "experimental.text.complete": (_input: {
            sessionID: string;
            messageID: string;
            partID: string;
        }, output: {
            text: string;
        }) => Promise<void>;
        "chat.message": (input: {
            sessionID?: string;
            variant?: string;
            agent?: string;
            model?: {
                providerID?: string;
                modelID?: string;
            };
        }) => Promise<void>;
        event: (input: {
            event: {
                type: string;
                properties?: unknown;
            };
        }) => Promise<void>;
        "command.execute.before": (input: unknown, output: unknown) => Promise<unknown>;
        "tool.execute.after": (input: unknown, output?: unknown) => Promise<void>;
    } & {
        rustToolBackends?: import("../rust-tool-backends").RustToolBackends;
    }) | null;
    rustToolBackends: import("../rust-tool-backends").RustToolBackends | undefined;
}>;
//# sourceMappingURL=create-session-hooks.d.ts.map