import type { AgentToolResult } from "@earendil-works/pi-agent-core";
import { type ContextUsage, type ExtensionAPI, type ExtensionContext, type RegisteredCommand, SessionManager, SettingsManager, type SessionBoundaryDraft, type ToolDefinition } from "@earendil-works/pi-coding-agent";
export type ExtensionTestEnvironment = {
    readonly cwd: string;
    readonly agentDir: string;
    beforeEach(): void;
    afterEach(): void;
    newNotesRoot(): string;
    dispose(): void;
};
/**
 * Install the process-level settings and notes roots needed by one test file.
 * The caller owns the lifecycle hooks; this helper never registers tests or hooks.
 */
export declare function installExtensionTestEnvironment(prefix?: string): ExtensionTestEnvironment;
export type Notice = {
    message: string;
    type?: "info" | "warning" | "error";
};
export declare function writeJson(path: string, value: unknown): void;
export type SettingsFixture = {
    cwd: string;
    agentDir: string;
};
/**
 * Materialize global (agentDir/settings.json) and project (cwd/.pi/settings.json)
 * settings in temp directories, then read them back through the same public
 * SettingsManager.create the extension uses. Never touches the real ~/.pi.
 */
export declare function settingsFixture(options?: {
    global?: Record<string, unknown>;
    project?: Record<string, unknown>;
    reserveTokens?: number;
}): SettingsFixture;
export type EventHandler = (event: never, ctx: ExtensionContext) => unknown;
type SendMessageArg = Parameters<ExtensionAPI["sendMessage"]>[0];
export type SentMessage = {
    message: SendMessageArg;
    options: {
        triggerTurn?: boolean;
    } | undefined;
};
export type Captured = {
    tools: Map<string, ToolDefinition>;
    handlers: Map<string, EventHandler[]>;
    commands: Map<string, CommandOptions>;
    sent: SentMessage[];
    contextMessages: unknown[];
    flags: string[];
};
export type CommandOptions = Omit<RegisteredCommand, "name" | "sourceInfo">;
export type CompactionHookResult = {
    cancel: true;
} | {
    compaction: {
        summary: string;
        firstKeptEntryId: string | null;
        tokensBefore: number;
        details?: unknown;
    };
} | undefined;
/** TypeBox's TSchema does not expose `type`/`required` statically; read them structurally. */
export declare function objectSchema(tool: ToolDefinition | undefined): {
    type?: string;
    required?: string[];
} | undefined;
export declare function manager(persisted?: boolean): SessionManager;
export declare function makeExtension(sessionManager: SessionManager, settingsManager?: SettingsManager): Captured;
export declare function explicitBoot(ctx: ExtensionContext, currentWindowId: string, previousWindowId: string | undefined): Promise<string>;
export declare function context(sessionManager: SessionManager, compact?: ExtensionContext["compact"], usage?: ContextUsage, idle?: boolean, cwd?: string, projectTrusted?: boolean, model?: string | {
    provider: string;
    id: string;
}): ExtensionContext;
export declare function noticesOf(ctx: ExtensionContext): Notice[];
export declare function sentOf(captured: Captured, customType: string): SentMessage[];
export declare function call(captured: Captured, name: string, params: Record<string, unknown>, ctx: ExtensionContext): Promise<AgentToolResult<unknown>>;
export declare function resultJson<T>(result: AgentToolResult<unknown>): T;
/** Assert the delivered wire text fits the tool-output budget, header included for raw reads. */
export declare function assertWithinBudget(result: AgentToolResult<unknown>, message: string): void;
/** Decoded raw read response using the shared READ WINDOW grammar. */
export type ReadWindow = {
    header: string;
    content: string;
    offset_chars: number;
    total_chars: number;
    next_offset_chars: number | null;
    details: Record<string, unknown>;
};
/** Decode either raw read without including its shared metadata block in the payload. */
export declare function resultRead(result: AgentToolResult<unknown>): ReadWindow;
export declare function runManualCompact(captured: Captured, ctx: ExtensionContext): Promise<CompactionHookResult>;
export declare function runHandlers(captured: Captured, name: string, event: unknown, ctx: ExtensionContext): Promise<void>;
export declare function runCommand(captured: Captured, name: string, args: string, ctx: ExtensionContext): Promise<Notice[]>;
export type ContextHookResult = {
    messages: unknown[];
} | undefined;
export declare function runContextHook(captured: Captured, ctx: ExtensionContext, eventOverride?: Record<string, unknown>): Promise<ContextHookResult>;
export declare function runContextWithSystemHook(captured: Captured, ctx: ExtensionContext, messages: unknown[]): Promise<ContextHookResult>;
export declare function commitTurnEndBoundary(captured: Captured, sessionManager: SessionManager, ctx: ExtensionContext): Promise<{
    entries: SessionBoundaryDraft[];
    continue: boolean;
}>;
export declare function appendText(sessionManager: SessionManager, role: "user" | "assistant" | "toolResult", text: string, toolName?: string): string;
export {};