/**
 * Core chat types and enums
 */
export declare const CHAT_TYPE: {
    readonly CLIENT: "CLIENT_CHAT";
    readonly ADMIN: "ADMIN_AI_CHAT";
};
export type ChatType = typeof CHAT_TYPE[keyof typeof CHAT_TYPE];
export declare const OWNER_TYPE: {
    readonly CLIENT: "CLIENT";
    readonly ADMIN: "ADMIN";
    readonly ASSISTANT: "ASSISTANT";
};
export type OwnerType = typeof OWNER_TYPE[keyof typeof OWNER_TYPE];
export declare const MESSAGE_ROLE: {
    readonly USER: "user";
    readonly ASSISTANT: "assistant";
    readonly ERROR: "error";
    readonly SYSTEM: "system";
};
export type MessageRole = typeof MESSAGE_ROLE[keyof typeof MESSAGE_ROLE];
export declare const ASSISTANT_TYPE: {
    readonly FAE: "fae";
    readonly MINGO: "mingo";
};
export type AssistantType = typeof ASSISTANT_TYPE[keyof typeof ASSISTANT_TYPE];
export declare const AUTHOR_TYPE: {
    readonly USER: "user";
    readonly ADMIN: "admin";
    readonly FAE: "fae";
    readonly MINGO: "mingo";
    readonly SYSTEM: "system";
};
export type AuthorType = typeof AUTHOR_TYPE[keyof typeof AUTHOR_TYPE];
export declare const APPROVAL_STATUS: {
    readonly PENDING: "pending";
    readonly APPROVED: "approved";
    readonly REJECTED: "rejected";
};
export type ChatApprovalStatus = typeof APPROVAL_STATUS[keyof typeof APPROVAL_STATUS];
export declare const CONNECTION_STATUS: {
    readonly CONNECTING: "connecting";
    readonly CONNECTED: "connected";
    readonly DISCONNECTED: "disconnected";
    readonly RECONNECTING: "reconnecting";
    readonly CLOSED: "closed";
    readonly ERROR: "error";
};
export type ConnectionStatus = typeof CONNECTION_STATUS[keyof typeof CONNECTION_STATUS];
export interface MessageOwner {
    type: OwnerType;
    machineId?: string;
    userId?: string;
    model?: string;
    user?: {
        id: string;
        firstName?: string;
        lastName?: string;
        /** Optional author avatar. Host queries it on the message owner (e.g.
         *  GraphQL `User.image`); `imageUrl` may be relative — the host is
         *  responsible for resolving it to an absolute/proxied URL. */
        image?: {
            imageUrl?: string | null;
        } | null;
    };
}
/**
 * Canonical key shape for the `chatRefs` map carried on every Message —
 * `${docType}:${externalId}`. The chat-message renderer looks up inline
 * `[card://<type>:<id>]` markers via this same key shape, so keeping the
 * construction in one place avoids divergence between the writer
 * (server-driven attach in decision_resolved handler) and the readers
 * (renderingPlan in chat-message-enhanced).
 *
 * Pure function — no runtime cost vs. inline template literal — but the
 * call-site reads as "the chat-ref key for this ref" rather than as a
 * generic string-concat, which is what the eye is hunting for when
 * scanning the file for ref-keyed logic.
 */
export declare function buildChatRefKey(docType: string, externalId: string): string;
import type { MessageContent, MessageSegment } from './message.types';
/** Helper function to check if content is structured (segment array). */
export declare function isStructuredContent(content: MessageContent): content is MessageSegment[];
/** Normalize either a string or segment array into a uniform segment array. */
export declare function normalizeContent(content: MessageContent): MessageSegment[];
export interface TextEventData {
    type: 'TEXT';
    text: string;
}
export interface ToolExecutionEventData {
    type: 'EXECUTING_TOOL' | 'EXECUTED_TOOL';
    integratedToolType: string;
    toolFunction: string;
    parameters?: Record<string, any>;
    result?: string;
    success?: boolean;
}
export type SSEEventData = TextEventData | ToolExecutionEventData;
export interface QuickAction {
    id: string;
    text: string;
}
//# sourceMappingURL=chat.types.d.ts.map