import type { ReadonlyJSONValue } from "assistant-stream/utils";
import type { RuntimeCapabilities, SpeechState, VoiceSessionState, ThreadSuggestion } from "../../runtime/interfaces/thread-runtime-core.js";
import type { ExportedMessageRepository } from "../../runtime/utils/message-repository.js";
import type { Unsubscribe } from "../../types/unsubscribe.js";
import type { ThreadMessageLike } from "../../runtime/utils/thread-message-like.js";
import type { CreateAppendMessage, CreateStartRunConfig, CreateResumeRunConfig, ThreadRuntime } from "../../runtime/api/thread-runtime.js";
import type { ModelContext } from "../../model-context/types.js";
import type { MessageMethods, MessageState } from "./message.js";
import type { ComposerMethods, ComposerState } from "./composer.js";
export type ThreadState = {
    /**
     * Whether the thread is empty. A thread is considered empty when it has no messages and is not loading.
     */
    readonly isEmpty: boolean;
    /**
     * Whether the thread is disabled. Disabled threads cannot receive new messages.
     */
    readonly isDisabled: boolean;
    /**
     * Whether the thread is loading its history.
     */
    readonly isLoading: boolean;
    /**
     * Whether the thread is running. A thread is considered running when there is an active stream connection to the backend.
     */
    readonly isRunning: boolean;
    /**
     * The capabilities of the thread, such as whether the thread supports editing, branch switching, etc.
     */
    readonly capabilities: RuntimeCapabilities;
    /**
     * The messages in the currently selected branch of the thread.
     */
    readonly messages: readonly MessageState[];
    /**
     * The thread state.
     * @deprecated This feature is experimental
     */
    readonly state: ReadonlyJSONValue;
    /**
     * Follow up message suggestions to show the user.
     */
    readonly suggestions: readonly ThreadSuggestion[];
    /**
     * Custom extra information provided by the runtime.
     */
    readonly extras: unknown;
    /** @deprecated This API is still under active development and might change without notice. */
    readonly speech: SpeechState | undefined;
    readonly voice: VoiceSessionState | undefined;
    readonly composer: ComposerState;
};
export type ThreadMethods = {
    /**
     * Get the current state of the thread.
     */
    getState(): ThreadState;
    /**
     * The thread composer runtime.
     */
    composer(): ComposerMethods;
    /**
     * Append a new message to the thread.
     *
     * @example ```ts
     * // append a new user message with the text "Hello, world!"
     * threadRuntime.append("Hello, world!");
     * ```
     *
     * @example ```ts
     * // append a new assistant message with the text "Hello, world!"
     * threadRuntime.append({
     *   role: "assistant",
     *   content: [{ type: "text", text: "Hello, world!" }],
     * });
     * ```
     */
    append(message: CreateAppendMessage): void;
    /**
     * Start a new run with the given configuration.
     * @param config The configuration for starting the run
     */
    startRun(config: CreateStartRunConfig): void;
    /**
     * Resume a run with the given configuration.
     * @param config The configuration for resuming the run
     */
    resumeRun(config: CreateResumeRunConfig): void;
    /**
     * @deprecated Use `resumeRun` instead.
     */
    unstable_resumeRun(config: CreateResumeRunConfig): void;
    cancelRun(): void;
    getModelContext(): ModelContext;
    export(): ExportedMessageRepository;
    import(repository: ExportedMessageRepository): void;
    /**
     * Reset the thread with optional initial messages.
     * @param initialMessages - Optional array of initial messages to populate the thread
     */
    reset(initialMessages?: readonly ThreadMessageLike[]): void;
    message(selector: {
        id: string;
    } | {
        index: number;
    }): MessageMethods;
    /** @deprecated This API is still under active development and might change without notice. */
    stopSpeaking(): void;
    connectVoice(): void;
    disconnectVoice(): void;
    getVoiceVolume(): number;
    subscribeVoiceVolume(callback: () => void): Unsubscribe;
    muteVoice(): void;
    unmuteVoice(): void;
    __internal_getRuntime?(): ThreadRuntime;
};
export type ThreadMeta = {
    source: "threads";
    query: {
        type: "main";
    };
};
export type ThreadEvents = {
    /**
     * @deprecated State-derivable. Observe `isRunning` flipping to `true` via
     * `useAuiState` instead. Kept for backward compatibility.
     */
    "thread.runStart": {
        threadId: string;
    };
    /**
     * @deprecated State-derivable. Observe `isRunning` flipping to `false` via
     * `useAuiState` instead. Kept for backward compatibility.
     */
    "thread.runEnd": {
        threadId: string;
    };
    /**
     * @deprecated State-derivable. This event fires before the first message is
     * added; observe `messages` becoming non-empty via `useAuiState` instead of
     * reading state inside this event handler. Kept for backward compatibility.
     */
    "thread.initialize": {
        threadId: string;
    };
    /**
     * Truly transient. Model context lives in a provider, not in thread state,
     * so this event has no state-derivable equivalent.
     */
    "thread.modelContextUpdate": {
        threadId: string;
    };
};
export type ThreadClientSchema = {
    methods: ThreadMethods;
    meta: ThreadMeta;
    events: ThreadEvents;
};
//# sourceMappingURL=thread.d.ts.map