import type { AssistantMessage, Usage } from "@bastani/pi-ai/compat";
import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
/** Method surface installed onto InteractiveModeBase by sibling modules. */
import type { MarkdownTransformer, SessionRecoveryReason, ToolRenderers } from "../../core/extensions/types.ts";
import type { CustomEntry, SessionEntry } from "../../core/session-manager.ts";
import type { FullscreenExitOutput } from "../../core/settings-manager.ts";
import type { ToolStatus } from "../../utils/tools-manager.ts";
import type { JsonAgentSessionEvent } from "../json-event.ts";
import type { AtomicWorkingLoader } from "./components/atomic-working-status.ts";
import type { AgentMessage, AgentSessionEvent, Api, AppKeybinding, AuthSelectorProvider, AutocompleteProvider, ChatMessageEntry, ChatMessageRenderOptions, Component, Container, EditorFactory, ExtensionCommandContext, ExtensionRunner, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, HostCustomUiState, HostCustomUiStateListener, Keybinding, KeybindingsManager, LoaderIndicatorOptions, LoginDialogComponent, MarkdownTheme, Message, MissingSessionCwdError, Model, OAuthSelectPrompt, OverlayHandle, OverlayOptions, ProjectTrustContext, ReadonlyFooterDataProvider, ResourceDiagnostic, SessionContext, SlashCommand, SourceInfo, Theme, TUI, VerbatimCompactionResult } from "./interactive-mode-deps.ts";
import type { InteractiveSubmission } from "./interactive-submission.ts";
import type { BlockedStatus } from "./program-status-reporter.ts";
declare module "./interactive-mode-base.ts" {
    interface InteractiveModeBase {
        getAutocompleteSourceTag(sourceInfo?: SourceInfo): string | undefined;
        prefixAutocompleteDescription(description: string | undefined, sourceInfo?: SourceInfo): string | undefined;
        getBuiltInCommandConflictDiagnostics(extensionRunner: ExtensionRunner): ResourceDiagnostic[];
        createBaseAutocompleteProvider(): AutocompleteProvider;
        buildRemoteSlashCommands(localCommands: SlashCommand[]): SlashCommand[];
        setupAutocompleteProvider(): void;
        showStartupNoticesIfNeeded(targetContainer?: Container): void;
        reportModelCatalogWarning(targetContainer?: Container): void;
        reportedModelCatalogWarning: string | undefined;
        hadLastChangelogVersionAtStartup: boolean;
        firstRunNoticeVisible: boolean;
        firstRunOnboardingNoticeComponents: Component[];
        initializeFirstRunOnboardingMarkers(): void;
        isFirstRunOnboardingEligible(): boolean;
        clearFirstRunOnboardingUi(): void;
        init(): Promise<void>;
        completeDeferredStartup(): Promise<void>;
        retryDeferredModelRestore(targetContainer?: Container): Promise<void>;
        updateTerminalTitle(): void;
        run(): Promise<void>;
        checkForPackageUpdates(): Promise<string[]>;
        checkTmuxKeyboardSetup(): Promise<string | undefined>;
        getChangelogForDisplay(): string | undefined;
        reportInstallTelemetry(version: string): void;
        getMarkdownThemeWithSettings(): MarkdownTheme;
        getMarkdownTransformers(): MarkdownTransformer[];
        formatDisplayPath(p: string): string;
        formatExtensionDisplayPath(path: string): string;
        formatContextPath(p: string): string;
        getStartupModelLabel(): string;
        getStartupIdentityText(maxWidth?: number, gap?: number, manifestoPhase?: number): string;
        getAtomicAnsiMarkLines(gap?: number): string[];
        getStartupExpansionState(): boolean;
        shouldShowStartupHeader(): boolean;
        shouldShowStartupDetails(): boolean;
        getShortPath(fullPath: string, sourceInfo?: SourceInfo): string;
        getCompactPathLabel(resourcePath: string, sourceInfo?: SourceInfo): string;
        getCompactPackageSourceLabel(sourceInfo?: SourceInfo): string;
        getCompactExtensionLabel(resourcePath: string, sourceInfo?: SourceInfo): string;
        getCompactDisplayPathSegments(resourcePath: string): string[];
        getCompactNonPackageExtensionLabel(resourcePath: string, index: number, allPaths: Array<{
            path: string;
            segments: string[];
        }>): string;
        getCompactExtensionLabels(extensions: Array<{
            path: string;
            sourceInfo?: SourceInfo;
        }>): string[];
        getDisplaySourceInfo(sourceInfo?: SourceInfo): {
            label: string;
            scopeLabel?: string;
            color: "accent" | "muted";
        };
        getScopeGroup(sourceInfo?: SourceInfo): "user" | "project" | "path";
        isPackageSource(sourceInfo?: SourceInfo): boolean;
        buildScopeGroups(items: Array<{
            path: string;
            sourceInfo?: SourceInfo;
        }>): Array<{
            scope: "user" | "project" | "path";
            paths: Array<{
                path: string;
                sourceInfo?: SourceInfo;
            }>;
            packages: Map<string, Array<{
                path: string;
                sourceInfo?: SourceInfo;
            }>>;
        }>;
        formatScopeGroups(groups: Array<{
            scope: "user" | "project" | "path";
            paths: Array<{
                path: string;
                sourceInfo?: SourceInfo;
            }>;
            packages: Map<string, Array<{
                path: string;
                sourceInfo?: SourceInfo;
            }>>;
        }>, options: {
            formatPath: (item: {
                path: string;
                sourceInfo?: SourceInfo;
            }) => string;
            formatPackagePath: (item: {
                path: string;
                sourceInfo?: SourceInfo;
            }, source: string) => string;
        }): string;
        findSourceInfoForPath(p: string, sourceInfos: Map<string, SourceInfo>): SourceInfo | undefined;
        formatPathWithSource(p: string, sourceInfo?: SourceInfo): string;
        formatDiagnostics(diagnostics: readonly ResourceDiagnostic[], sourceInfos: Map<string, SourceInfo>): string;
        addResourceDisclosure(options: {
            contextFiles: ReadonlyArray<{
                path: string;
            }>;
            skills: ReadonlyArray<{
                filePath: string;
                name: string;
            }>;
            prompts: ReadonlyArray<{
                filePath: string;
                name: string;
            }>;
            extensions: ReadonlyArray<{
                path: string;
                sourceInfo?: SourceInfo;
            }>;
            expandedSections: {
                context?: string;
                skills?: string;
                prompts?: string;
                extensions?: string;
            };
            targetContainer?: Container;
        }): void;
        showLoadedResources(options?: {
            extensions?: Array<{
                path: string;
                sourceInfo?: SourceInfo;
            }>;
            force?: boolean;
            showDiagnosticsWhenQuiet?: boolean;
            targetContainer?: Container;
        }): void;
        bindCurrentSessionExtensions(): Promise<void>;
        applyRuntimeSettings(): void;
        rebindCurrentSession(): Promise<void>;
        handleFatalRuntimeError(prefix: string, error: unknown): Promise<never>;
        renderCurrentSessionState(): void;
        startSessionRecovery(reason: SessionRecoveryReason): void;
        getRegisteredToolDefinition(toolName: string): ToolRenderers | undefined;
        setupExtensionShortcuts(extensionRunner: ExtensionRunner): void;
        setExtensionStatus(key: string, text: string | undefined): void;
        getWorkingLoaderMessage(): string;
        createWorkingLoader(): AtomicWorkingLoader;
        clearWorkingLoader(): void;
        stopWorkingLoader(): void;
        showWorkingLoaderNow(): void;
        setWorkingVisible(visible: boolean): void;
        setWorkingIndicator(options?: LoaderIndicatorOptions): void;
        setHiddenThinkingLabel(label?: string): void;
        setExtensionWidget(key: string, content: string[] | ((tui: TUI, thm: Theme) => Component & {
            dispose?(): void;
        }) | undefined, options?: ExtensionWidgetOptions): void;
        clearExtensionWidgets(): void;
        resetExtensionUI(): void;
        renderWidgets(): void;
        renderWidgetContainer(container: Container, widgets: Map<string, Component & {
            dispose?(): void;
        }>, spacerWhenEmpty: boolean, leadingSpacer: boolean): void;
        setExtensionFooter(factory: ((tui: TUI, thm: Theme, footerData: ReadonlyFooterDataProvider) => Component & {
            dispose?(): void;
        }) | undefined): void;
        setExtensionHeader(factory: ((tui: TUI, thm: Theme) => Component & {
            dispose?(): void;
        }) | undefined): void;
        addExtensionTerminalInputListener(handler: (data: string) => {
            consume?: boolean;
            data?: string;
        } | undefined): () => void;
        clearExtensionTerminalInputListeners(): void;
        getHostCustomUiState(): HostCustomUiState;
        notifyHostCustomUiStateListeners(): void;
        beginHostInlineCustomUi(purpose?: "prompt" | "navigation"): () => void;
        beginInlineCustomUiFocusDeferral(): () => void;
        shouldDeferInlineCustomUiFocus(): boolean;
        focusHostInlineCustomUi(): boolean;
        onHostCustomUiStateChange(listener: HostCustomUiStateListener): () => void;
        onExtensionWidgetRelease(key: string, listener: () => void): () => void;
        notifyExtensionWidgetRelease(key: string): void;
        createProjectTrustContext(cwd: string): ProjectTrustContext;
        createExtensionUIContext(): ExtensionUIContext;
        showExtensionSelector(title: string, options: string[], opts?: ExtensionUIDialogOptions, blocked?: BlockedStatus): Promise<string | undefined>;
        showExtensionConfirm(title: string, message: string, opts?: ExtensionUIDialogOptions): Promise<boolean>;
        promptForMissingSessionCwd(error: MissingSessionCwdError): Promise<string | undefined>;
        showExtensionInput(title: string, placeholder?: string, opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
        showExtensionEditor(title: string, prefill?: string, opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
        setCustomEditorComponent(factory: EditorFactory | undefined): void;
        showExtensionNotify(message: string, type?: "info" | "warning" | "error"): void;
        showExtensionCustom<T>(factory: (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (result: T) => void) => (Component & {
            dispose?(): void;
        }) | Promise<Component & {
            dispose?(): void;
        }>, options?: {
            purpose?: "prompt" | "navigation";
            overlay?: boolean;
            deferInlineCustomUiFocus?: boolean;
            handlesInternalUiAction?: boolean;
            /** Overlay-only: bound the overlay and reserve transcript scroll extent. */
            reserveTranscriptRows?: boolean;
            signal?: AbortSignal;
            overlayOptions?: OverlayOptions | (() => OverlayOptions);
            onHandle?: (handle: OverlayHandle) => void;
        }): Promise<T>;
        showExtensionError(extensionPath: string, error: string, stack?: string): void;
        setupKeyHandlers(): void;
        handleClipboardImagePaste(): Promise<void>;
        setupEditorSubmitHandler(): void;
        deliverStartupReplayPrompt(text: string): void;
        drainStartupReplayCommands(): Promise<void>;
        advanceStartupInputReplay(submittedText: string): void;
        subscribeToAgent(): void;
        handleEvent(event: AgentSessionEvent | JsonAgentSessionEvent): Promise<void>;
        getUserMessageText(message: Message): string;
        showStatus(message: string, persist?: boolean): void;
        /** Report a managed-tool (fd/rg) readiness update inside the transcript. */
        showManagedToolStatus(status: ToolStatus): void;
        /** Bring fd/rg to readiness after first paint; progress lands in the transcript. */
        ensureManagedToolsReady(): Promise<void>;
        chatMessageRenderOptions(): ChatMessageRenderOptions;
        addRenderedChatEntry(entry: ChatMessageEntry): Component;
        addCompactionBoundaryToChat(result: VerbatimCompactionResult): void;
        addCompactionCostNotice(kind: "compaction" | "branch_summary", usage: Usage): void;
        maybeShowAssistantDiagnostics(message: AssistantMessage): void;
        maybeShowInstallChangeWarning(): boolean;
        addMessageToChat(message: AgentMessage, options?: {
            populateHistory?: boolean;
        }): void;
        addCustomEntryToChat(entry: CustomEntry): void;
        renderSessionContext(sessionContext: SessionContext, options?: {
            updateFooter?: boolean;
            populateHistory?: boolean;
        }): void;
        renderSessionEntries(entries: SessionEntry[], options?: {
            updateFooter?: boolean;
            populateHistory?: boolean;
            suppressCompactionBoundary?: VerbatimCompactionResult;
        }): void;
        renderInitialMessages(): void;
        attachStartupNoticesContainer(options?: {
            resetDetached?: boolean;
        }): void;
        getUserInput(): Promise<InteractiveSubmission>;
        runUserPromptTurn(submission: InteractiveSubmission | string): Promise<void>;
        renderDeferredUserInput(text: string): void;
        consumeDeferredRenderedUserInput(text: string): boolean;
        discardDeferredRenderedUserInput(text: string): void;
        ensureDeferredStartupComplete(): Promise<void>;
        rebuildChatFromMessages(options?: {
            suppressCompactionBoundary?: VerbatimCompactionResult;
            resetStartupDisclosure?: boolean;
        }): void;
        handleCtrlC(): void;
        interruptActiveOperation(): boolean;
        handleCtrlD(): void;
        shutdown(options?: {
            fromSignal?: boolean;
        }): Promise<void>;
        emergencyTerminalExit(): never;
        uncaughtCrash(error: Error): never;
        getCrashExtensionHint(error: unknown): string | undefined;
        checkShutdownRequested(): Promise<void>;
        registerSignalHandlers(): void;
        unregisterSignalHandlers(): void;
        handleCtrlZ(): void;
        handleFollowUp(): Promise<void>;
        handleDequeue(): void;
        refreshBuiltInHeader(): void;
        updateEditorBorderColor(): void;
        cycleThinkingLevel(): Promise<void>;
        cycleModel(direction: "forward" | "backward"): Promise<void>;
        toggleToolOutputExpansion(): void;
        setToolsExpanded(expanded: boolean): void;
        toggleThinkingBlockVisibility(): void;
        updateThinkingBlockVisibility(): void;
        openExternalEditor(): Promise<void>;
        clearEditor(): void;
        showError(errorMessage: string): void;
        showWarning(warningMessage: string, targetContainer?: Container): void;
        showNewVersionNotification(newVersion: string, targetContainer?: Container): void;
        showPackageUpdateNotification(packages: string[], targetContainer?: Container): void;
        getAllQueuedMessages(): {
            steering: string[];
            followUp: string[];
        };
        clearAllQueues(options?: {
            preserveUnprotectedCustomMessages?: boolean;
        }): {
            steering: string[];
            followUp: string[];
        };
        updatePendingMessagesDisplay(): void;
        restoreQueuedMessagesToEditor(options?: {
            abort?: boolean;
            currentText?: string;
            preserveUnprotectedCustomMessages?: boolean;
        }): number;
        queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
        isExtensionCommand(text: string): boolean;
        flushCompactionQueue(options?: {
            willRetry?: boolean;
            afterPrompt?: boolean;
        }): Promise<void>;
        flushPendingBashComponents(): void;
        showSelector(create: (done: () => void) => {
            component: Component;
            focus: Component;
            dispose?: () => void;
        }): void;
        showSettingsSelector(): void;
        handleModelCommand(searchTerm?: string): Promise<void>;
        handleThinkingCommand(searchTerm?: string): Promise<void>;
        selectThinkingLevel(level: ThinkingLevel): Promise<void>;
        showThinkingSelector(): void;
        findExactModelMatch(searchTerm: string): Promise<Model<Api> | undefined>;
        getModelCandidates(): Promise<Model<Api>[]>;
        updateAvailableProviderCount(): Promise<void>;
        maybeWarnAboutAnthropicSubscriptionAuth(model?: Model<Api> | undefined, targetContainer?: Container): Promise<void>;
        showModelSelector(initialSearchInput?: string): void;
        showModelsSelector(): void;
        showUserMessageSelector(): Promise<void>;
        handleCloneCommand(): Promise<void>;
        maybeSaveImplicitProjectTrustAfterReload(): boolean;
        showTrustSelector(): void;
        showTreeSelector(initialSelectedId?: string): Promise<void>;
        showSessionSelector(): void;
        handleResumeSession(sessionId: string, options?: Parameters<ExtensionCommandContext["switchSession"]>[1], sessionDirectory?: string): Promise<{
            cancelled: boolean;
        }>;
        getLoginProviderOptions(authType?: "oauth" | "api_key"): AuthSelectorProvider[];
        getLogoutProviderOptions(): AuthSelectorProvider[];
        handleLoginCommand(providerRef?: string): Promise<void>;
        startProviderLogin(providerOption: AuthSelectorProvider, onBack?: () => void): Promise<void>;
        showLoginAuthTypeSelector(providerOptions?: AuthSelectorProvider[]): void;
        showLoginProviderSelector(authType?: "oauth" | "api_key", initialSearchInput?: string): void;
        showOAuthSelector(mode: "login" | "logout", initialSearchInput?: string): Promise<void>;
        completeProviderAuthentication(providerId: string, providerName: string, authType: "oauth" | "api_key", previousModel: Model<Api> | undefined, options?: {
            modelsRefreshed?: boolean;
        }): Promise<void>;
        showBedrockSetupDialog(providerId: string, providerName: string, onBack?: () => void): void;
        showApiKeyLoginDialog(providerId: string, providerName: string, onBack?: () => void): Promise<void>;
        showOAuthLoginSelect(dialog: LoginDialogComponent, prompt: OAuthSelectPrompt): Promise<string | undefined>;
        showLoginDialog(providerId: string, providerName: string, onBack?: () => void): Promise<void>;
        handleReloadCommand(): Promise<void>;
        handleExportCommand(text: string): Promise<void>;
        getPathCommandArgument(text: string, command: "/export" | "/import"): string | undefined;
        handleImportCommand(text: string): Promise<void>;
        handleShareCommand(): Promise<void>;
        handleCopyCommand(): Promise<void>;
        handleNameCommand(text: string): Promise<void>;
        handleSessionCommand(): void;
        handleToolsCommand(): Promise<void>;
        handleChangelogCommand(): void;
        getAppKeyDisplay(action: AppKeybinding): string;
        getEditorKeyDisplay(action: Keybinding): string;
        jumpToTranscriptEnd(): void;
        setFullscreenCopyOnSelect(enabled: boolean): void;
        handleHotkeysCommand(): void;
        handleClearCommand(): Promise<void>;
        handleDebugCommand(): void;
        handleArminSaysHi(): void;
        handleDementedDelves(): void;
        handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
        handleCompactCommand(): Promise<void>;
        stop(fullscreenExitOutput?: FullscreenExitOutput): void;
    }
}
//# sourceMappingURL=interactive-mode-surface.d.ts.map