import { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';

type BashPolicy = "strict_readonly" | "non_destructive" | "off";
/** Permission action for tool access control */
type PermissionAction = "allow" | "ask" | "deny";
/** Overrides for bash command patterns */
interface BashPatternOverrides {
    add?: string[];
    remove?: string[];
    severity?: Record<string, BashPatternSeverity>;
}
type BashPatternSeverity = "allow" | "ask" | "block";
/** Configuration for bash command patterns */
interface BashPatternConfig {
    safe?: BashPatternOverrides;
    destructive?: BashPatternOverrides;
}
/** Resolved bash patterns ready for evaluation */
interface ResolvedBashPatterns {
    safe: RegExp[];
    destructive: RegExp[];
    safeSource?: string[];
    destructiveSource?: string[];
    severity?: Map<string, BashPatternSeverity>;
}
interface ModeDefinition {
    mode: string;
    enabled_tools?: string[];
    bash_policy?: BashPolicy;
    prompt_suffix?: string;
    description?: string;
    border_label?: string;
    border_style?: 'accent' | 'warning' | 'success' | 'muted';
    allowed_agents?: string[];
    permissions?: Record<string, PermissionAction>;
    bash_patterns?: BashPatternConfig;
    auto_mode_switch?: boolean;
}
/** Extract a human-readable error message from unknown throw value */
declare function errorMessage(err: unknown): string;
/** Extract error code from unknown throw value (for Node.js fs errors etc.) */
declare function errorCode(err: unknown): string | undefined;
/** Default mode when none specified */
declare const DEFAULT_MODE: "orchestrator";
/** Modes to try when current mode is unavailable */
declare const SAFE_FALLBACK_MODES: readonly ["plan", "ask", "yolo"];
/** Fallback mode for interactive picker failures */
declare const PICKER_FALLBACK_MODE: "yolo";
/** Max allowed mode name length */
declare const MAX_MODE_NAME_LENGTH: 50;
/** Max chars shown in prompt suffix preview */
declare const SUFFIX_PREVIEW_LENGTH: 120;
/** Default user config path components */
declare const USER_CONFIG_DIR: ".pi";
declare const USER_CONFIG_FILE: "modes/config.yaml";

type DiagnosticLevel = "warning" | "error";
interface ModeCatalogDiagnostic {
    level: DiagnosticLevel;
    message: string;
    mode?: string;
    file?: string;
}
declare class ModeCatalog {
    readonly definitions: Map<string, ModeDefinition>;
    readonly loadedAt: number;
    readonly globalBashPatterns?: BashPatternConfig | undefined;
    constructor(definitions: Map<string, ModeDefinition>, loadedAt: number, globalBashPatterns?: BashPatternConfig | undefined);
    hasMode(mode: string): boolean;
    getDefinition(mode: string): ModeDefinition | undefined;
    modes(): string[];
    resolveMode(requested: string | undefined, fallbacks?: readonly string[], defaultMode?: string): string;
}
type ModeCatalogResult = {
    ok: true;
    catalog: ModeCatalog;
    diagnostics: ModeCatalogDiagnostic[];
} | {
    ok: false;
    diagnostics: ModeCatalogDiagnostic[];
};
interface LoadModeCatalogOptions {
    modesDir?: string;
    userConfigPath?: string;
    now?: () => number;
}
interface ParsedModeDocument {
    mode: string;
    file: string;
    parsed?: unknown;
    error?: string;
}
interface ParsedUserOverrides {
    file: string;
    parsed?: unknown;
    readError?: string;
    parseError?: string;
}
interface BuildModeCatalogInput {
    modeDocuments: readonly ParsedModeDocument[];
    userOverrides?: ParsedUserOverrides;
    diagnostics?: readonly ModeCatalogDiagnostic[];
    fileForMode?: (mode: string) => string;
    now?: () => number;
}
declare function buildModeCatalog(input: BuildModeCatalogInput): ModeCatalogResult;
declare function loadAllModes(options?: LoadModeCatalogOptions): Promise<ModeCatalogResult>;

declare class ModeFileWatcher {
    private readonly modesDir;
    private readonly userConfigPath;
    constructor(modesDir: string, userConfigPath: string);
    hasChanges(since: number): Promise<boolean>;
}

interface ModeSelectOption {
    name: string;
    description?: string;
}
interface EvaluateToolCallResult {
    block: boolean;
    reason?: string;
    warning?: string;
    suggestedModes?: string[];
}
/** Fire-and-forget side effects the Mode module produces. */
interface ModeEffects {
    setActiveTools(tools: string[]): void;
    persistMode(mode: string, sessionId?: string): void;
    notify(message: string, level: "info" | "warning" | "error"): void;
    setStatus(key: string, display: string): void;
}
/** Interactive queries whose answers shape policy verdicts. */
interface ModeDialogs {
    confirm(title: string, message: string): Promise<boolean>;
    select(prompt: string, options: string[]): Promise<string | undefined>;
}
/** Narrow read-only view of Mode for rendering (e.g. the editor border). */
interface ModeStatusReader {
    currentMode(): string;
    currentDefinition(): ModeDefinition | undefined;
}
interface ModeOptions {
    defaultMode?: string;
    safeFallbackModes?: readonly string[];
}
declare class Mode implements ModeStatusReader {
    private readonly pi;
    private readonly fileWatcher;
    private catalog;
    private _currentMode;
    private baselineTools;
    private ctx;
    private _sessionId;
    private readonly bypass;
    private reloadPending;
    private effects;
    private dialogs;
    private readonly defaultMode;
    private readonly safeFallbackModes;
    constructor(pi: ExtensionAPI, fileWatcher: ModeFileWatcher, options?: ModeOptions);
    bindContext(ctx: ExtensionContext | undefined): void;
    currentMode(): string;
    currentDefinition(): ModeDefinition | undefined;
    modes(): string[];
    definition(mode?: string): ModeDefinition | undefined;
    sessionId(): string | undefined;
    catalogDefinitions(): Map<string, ModeDefinition> | undefined;
    globalBashPatterns(): BashPatternConfig | undefined;
    activeTools(): string[];
    initialize(ctx: ExtensionContext, sessionId?: string): Promise<void>;
    /**
     * Read the last persisted mode from session history. Returns undefined when
     * nothing is recorded. Callers must still validate against the loaded catalog.
     */
    restoreFromSession(sessionId?: string): string | undefined;
    /**
     * Restore a mode using the precedence: CLI flag > derived (session or subagent fallback) > current > safe fallback.
     */
    restore(cliMode?: string, derivedMode?: string): void;
    captureBaselineTools(toolNames: string[]): void;
    setMode(mode: string): {
        ok: boolean;
        mode?: string;
        error?: string;
    };
    cycleMode(): void;
    acceptCatalog(catalog: ModeCatalog | {
        definitions: Map<string, ModeDefinition>;
        loadedAt: number;
        globalBashPatterns?: BashPatternConfig;
    }): void;
    evaluateToolCall(toolName: string, input: unknown): Promise<EvaluateToolCallResult | undefined>;
    switchMode(targetMode: string): {
        ok: boolean;
        mode?: string;
        error?: string;
    };
    handleCommand(args: string | undefined, selectMode: (options: ModeSelectOption[]) => Promise<string | undefined>): Promise<void>;
    reload(): Promise<void>;
    checkAndReload(): Promise<void>;
    buildPromptInjection(): string | undefined;
    beforeProviderRequest(payload: unknown): unknown;
    turnEnd(): void;
    setupEditor(): void;
    private applyModeChange;
    private pickRestoreMode;
    private firstAvailableMode;
    private persistMode;
    private updateStatus;
    private showStatus;
    private discoverAvailableAgents;
}

/**
 * Bash pattern engine — owns pattern definitions, resolution, matching, and validation.
 *
 * This module has no dependency on mode catalogs, tool policy, or delegation logic.
 * It is the single source of truth for what constitutes a safe, destructive, or
 * severity-overridden bash command.
 */

/** Resolve bash patterns from config and overrides */
declare function resolveBashPatterns(globalOverrides?: BashPatternConfig, modeOverrides?: BashPatternConfig): ResolvedBashPatterns;
/** Validate a regex pattern string */
declare function validateBashPattern(pattern: string): {
    valid: boolean;
    error?: string;
};
/** Resolve the effective bash policy for a mode, falling back to defaults. */
declare function resolveBashPolicy(mode: string, definition?: {
    bash_policy?: BashPolicy;
}): BashPolicy;
/** Check whether a bash command passes a mode's bash policy. Returns true if allowed. */
declare function isBashCommandAllowed(command: string, bashPolicy: BashPolicy, patterns: ResolvedBashPatterns): boolean;

/**
 * Mode tool policy — evaluates whether a tool call should be allowed, blocked, or
 * prompted in the current mode. Delegates bash pattern matching to bash-pattern-engine.
 */

type ModeCatalogMap = Map<string, {
    enabled_tools?: string[];
    bash_policy?: BashPolicy;
    allowed_agents?: string[];
    permissions?: Record<string, PermissionAction>;
    bash_patterns?: BashPatternConfig;
}>;
interface ModeToolPolicyInput {
    mode: string;
    definition?: ModeDefinition;
    toolName: string;
    input?: unknown;
    /** Full mode catalog. Undefined entries or empty enabled_tools = unrestricted (all tools allowed). */
    catalog?: ModeCatalogMap;
    /** Known available agent names from the subagent system. Used to validate allowed_agents. */
    availableAgents?: string[];
    /** Pre-resolved bash patterns. If omitted, engine resolves from raw configs below. */
    bashPatterns?: ResolvedBashPatterns;
    /** Global bash pattern config (from user config). Used when bashPatterns is omitted. */
    globalBashPatterns?: BashPatternConfig;
    /** Mode-specific bash pattern config. Used when bashPatterns is omitted. */
    modeBashPatterns?: BashPatternConfig;
}
interface ModeToolPolicyDecision {
    block: boolean;
    reason?: string;
    suggestedModes?: string[];
    warning?: string;
    ask?: boolean;
    askMessage?: string;
}
/**
 * Given a tool name (and optional bash command), return which modes from the catalog
 * would allow that tool call. Uses bash-pattern-engine directly for bash policy checks
 * — no call cycle with evaluateToolCall.
 */
declare function findModesForTool(toolName: string, definitions: ModeCatalogMap, input?: unknown, globalBashPatterns?: BashPatternConfig): string[];
declare function evaluateToolCall({ mode, definition, toolName, input, catalog, availableAgents, bashPatterns, globalBashPatterns, modeBashPatterns, }: ModeToolPolicyInput): ModeToolPolicyDecision;

declare function injectIntoPayload(payload: unknown, text: string): unknown;

declare function export_default(pi: ExtensionAPI): Promise<void>;

export { DEFAULT_MODE, type EvaluateToolCallResult, MAX_MODE_NAME_LENGTH, Mode, type ModeDialogs, type ModeEffects, ModeFileWatcher, type ModeSelectOption, type ModeStatusReader, PICKER_FALLBACK_MODE, SAFE_FALLBACK_MODES, SUFFIX_PREVIEW_LENGTH, USER_CONFIG_DIR, USER_CONFIG_FILE, buildModeCatalog, export_default as default, errorCode, errorMessage, evaluateToolCall, findModesForTool, injectIntoPayload, isBashCommandAllowed, loadAllModes, resolveBashPatterns, resolveBashPolicy, validateBashPattern };