/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import { EventEmitter } from 'node:events';
/**
 * Defines the severity level for user-facing feedback.
 * This maps loosely to UI `MessageType`
 */
export type FeedbackSeverity = 'info' | 'warning' | 'error';
/**
 * Payload for the 'user-feedback' event.
 */
export interface UserFeedbackPayload {
    /**
     * The severity level determines how the message is rendered in the UI
     * (e.g. colored text, specific icon).
     */
    severity: FeedbackSeverity;
    /**
     * The main message to display to the user in the chat history or stdout.
     */
    message: string;
    /**
     * The original error object, if applicable.
     * Listeners can use this to extract stack traces for debug logging
     * or verbose output, while keeping the 'message' field clean for end users.
     */
    error?: unknown;
}
/**
 * Payload for the 'memory-changed' event.
 */
export interface MemoryChangedPayload {
    fileCount: number;
}
export interface ConsoleLogPayload {
    type: string;
    content: string;
}
export interface OutputPayload {
    chunk: string | Uint8Array;
    encoding?: BufferEncoding;
    isStderr: boolean;
}
export declare enum CoreEvent {
    UserFeedback = "user-feedback",
    MemoryChanged = "memory-changed",
    ModelChanged = "model-changed",
    ConsoleLog = "console-log",
    Output = "output",
    ExternalEditorClosed = "external-editor-closed"
}
export declare class CoreEventEmitter extends EventEmitter {
    private _feedbackBacklog;
    private _outputBacklog;
    private _consoleLogBacklog;
    private static readonly MAX_BACKLOG_SIZE;
    constructor();
    /**
     * Sends actionable feedback to the user.
     * Buffers automatically if the UI hasn't subscribed yet.
     */
    emitFeedback(severity: FeedbackSeverity, message: string, error?: unknown): void;
    /**
     * Flushes buffered messages. Call this immediately after primary UI listener
     * subscribes.
     */
    drainFeedbackBacklog(): void;
    on(event: CoreEvent.UserFeedback, listener: (payload: UserFeedbackPayload) => void): this;
    on(event: CoreEvent.MemoryChanged, listener: (payload: MemoryChangedPayload) => void): this;
    on(event: CoreEvent.ModelChanged, listener: (model: string) => void): this;
    on(event: CoreEvent.ConsoleLog, listener: (payload: ConsoleLogPayload) => void): this;
    on(event: CoreEvent.Output, listener: (payload: OutputPayload) => void): this;
    off(event: CoreEvent.UserFeedback, listener: (payload: UserFeedbackPayload) => void): this;
    off(event: CoreEvent.MemoryChanged, listener: (payload: MemoryChangedPayload) => void): this;
    off(event: CoreEvent.ModelChanged, listener: (model: string) => void): this;
    off(event: CoreEvent.ConsoleLog, listener: (payload: ConsoleLogPayload) => void): this;
    off(event: CoreEvent.Output, listener: (payload: OutputPayload) => void): this;
    emit(event: CoreEvent.UserFeedback, payload: UserFeedbackPayload): boolean;
    emit(event: CoreEvent.MemoryChanged, payload: MemoryChangedPayload): boolean;
    emit(event: CoreEvent.ModelChanged, model: string): boolean;
    emit(event: CoreEvent.ConsoleLog, payload: ConsoleLogPayload): boolean;
    emit(event: CoreEvent.Output, payload: OutputPayload): boolean;
    emit(event: CoreEvent.ExternalEditorClosed): boolean;
    /**
     * Emits a model-changed event when the model is updated.
     */
    emitModelChanged(model: string): void;
    /**
     * Emits a console log event. Buffers if no listener is attached.
     */
    emitConsoleLog(type: string, content: string): void;
    /**
     * Emits an output event. Buffers if no listener is attached.
     */
    emitOutput(payload: OutputPayload): void;
    /**
     * Drains the output backlog, emitting all buffered events.
     */
    drainOutputBacklog(): void;
    /**
     * Drains the console log backlog, emitting all buffered events.
     */
    drainConsoleLogBacklog(): void;
    /**
     * Drains all backlogs (feedback, output, console log).
     */
    drainBacklogs(): void;
}
export declare const coreEvents: CoreEventEmitter;