import { type ComponentType, type ReactNode } from "react";
import type { MentionItemMedia } from "./types.js";
export type ComposerTranslate = (key: string, options?: Record<string, unknown>) => string;
export type ReasoningEffort = "auto" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
export interface EngineModelGroup {
    engine: string;
    label: string;
    models: string[];
    configured: boolean;
    /** Provider-owned connection state shown at the far edge of the row. */
    statusLabel?: string;
    /** Marks a configured local subscription so setup CTAs can stay hidden. */
    isSubscription?: boolean;
}
export interface ComposerModelState {
    selectedModel: string;
    selectedEngine: string;
    selectedEffort: ReasoningEffort;
    availableModels: EngineModelGroup[];
    isLoading: boolean;
    onModelChange: (model: string, engine: string) => void;
    onEffortChange: (effort: ReasoningEffort) => void;
}
export interface ComposerBuilderConnectFlow {
    hasFetchedStatus: boolean;
    configured: boolean;
    envManaged: boolean;
    connecting: boolean;
    statusResolved: boolean;
    error: string | null;
    start: () => void;
}
export interface AgentChatContextItem {
    key: string;
    title: string;
    context: string;
}
export interface ComposerAgentChatMessage {
    message: string;
    context?: string;
    mode?: "plan" | "act";
    submit?: boolean;
}
export interface ComposerAgentChatContextSetOptions extends AgentChatContextItem {
    openSidebar?: boolean;
    focus?: boolean;
}
export interface ComposerAgentChatOpenThreadRequest {
    threadId: string;
    onlyIfActiveThreadId?: string;
}
export interface ComposerBuilderConnectFlowOptions {
    enabled?: boolean;
    popupUrl?: string;
    trackingSource?: string;
    trackingFlow?: string;
    onConnected?: (state: {
        orgName: string | null;
    }) => void | Promise<void>;
}
export interface AgentComposerReference {
    label: string;
    icon?: string;
    media?: MentionItemMedia;
    source?: string;
    refType: string;
    refId?: string | null;
    refPath?: string | null;
    slotKey?: string;
    slotLabel?: string;
    metadata?: Record<string, unknown>;
    clearsSlots?: string[];
    relatedReferences?: AgentComposerReference[];
}
export interface AgentComposerReferenceInsertPayload extends AgentComposerReference {
    insertMessageId: string;
}
export interface VoiceContextPack {
    surface?: string;
    mode?: string;
    snippets?: Array<{
        label: string;
        value: string;
    }>;
    terms?: Array<{
        term: string;
        replacement?: string;
    }>;
}
export interface ComposerRuntimeAdapters {
    resolvePath?: (path: string) => string;
    translate?: ComposerTranslate;
    formatNumber?: (value: number, options?: Intl.NumberFormatOptions) => string;
    models?: {
        useChatModels?: (options: {
            enabled: boolean;
        }) => ComposerModelState;
        useAgentEngineConfigured?: (enabled: boolean) => {
            missing: boolean;
            state: string;
        };
        fetchAgentEngineConfiguredState?: (enabled: boolean, options: {
            timeoutMs: number;
        }) => Promise<"missing" | "configured" | string>;
        BuilderSetupCard?: ComponentType<any>;
        BuilderSetupContent?: ComponentType<any>;
        reasoning?: {
            defaultEffort?: ReasoningEffort;
            getOptionsForModel?: (model?: string) => ReasoningEffort[];
            label?: (effort: ReasoningEffort) => string;
            resolve?: (model: string, effort?: ReasoningEffort) => ReasoningEffort;
        };
    };
    agentChat?: {
        sendToAgentChat?: (input: ComposerAgentChatMessage) => void;
        setContextItem?: (input: ComposerAgentChatContextSetOptions) => void;
        requestThreadOpen?: (input: ComposerAgentChatOpenThreadRequest) => void;
        formatContextItems?: (items: readonly AgentChatContextItem[] | undefined) => string;
        normalizeReference?: (reference: unknown) => AgentComposerReference | null;
        StaleIndexBoundary?: ComponentType<any>;
    };
    builder?: {
        useConnectFlow?: (options: ComposerBuilderConnectFlowOptions) => ComposerBuilderConnectFlow;
        tryDelegateBuildRequest?: (text: string) => boolean;
        isTrustedFrameMessage?: (event: MessageEvent) => boolean;
        isTrustedBuilderMessage?: (event: MessageEvent) => boolean;
    };
    resources?: {
        useOrg?: () => {
            data?: {
                orgId?: string | null;
                role?: string | null;
            } | null;
        };
        isMcpIntegrationAvailable?: () => boolean;
        useCreateMcpServer?: () => {
            mutateAsync: (input: any) => Promise<unknown>;
        };
        McpIntegrationDialog?: ComponentType<any>;
    };
    voice?: {
        useProviderStatus?: () => {
            status: {
                builder?: boolean;
                openai?: boolean;
            } | null;
            refresh: () => void;
        };
        getBrowserTabId?: () => string;
        readAppState?: <T>(key: string) => T | null | undefined | Promise<T | null | undefined>;
        setAppState?: (key: string, value: unknown) => void | Promise<unknown>;
        subscribeSidebarState?: (listener: (detail: {
            open?: boolean;
        } | undefined) => void) => () => void;
        applyContextReplacements?: (text: string, context: VoiceContextPack | undefined) => string;
    };
}
export declare function ComposerRuntimeAdaptersProvider({ adapters, children, }: {
    adapters: ComposerRuntimeAdapters;
    children: ReactNode;
}): import("react").JSX.Element;
export declare function useComposerRuntimeAdapters(): ComposerRuntimeAdapters;
export declare const DEFAULT_REASONING_EFFORT: ReasoningEffort;
export declare function getReasoningEffortOptionsForModel(_model?: string): ReasoningEffort[];
export declare function reasoningEffortLabel(effort: ReasoningEffort): string;
export declare function resolveReasoningEffortSelection(_model: string, effort?: ReasoningEffort): ReasoningEffort;
export declare const AGENT_CHAT_INSERT_REFERENCE_EVENT = "agent-native:insert-composer-reference";
export declare const AGENT_CHAT_INSERT_REFERENCE_MESSAGE_TYPE = "agent-native:insert-composer-reference";
export declare function formatPromptContextItems(items: AgentChatContextItem[] | undefined): string;
export declare function applyVoiceContextReplacements(text: string, context: VoiceContextPack | undefined): string;
//# sourceMappingURL=runtime-adapters.d.ts.map