@acorex-platform/module-conversation-client 0.0.21

package/types/acorex-platform-module-conversation-client.d.ts

@@ -0,0 +1,1614 @@
+import * as _angular_core from '@angular/core';
+import { Provider, InjectionToken, Type, Signal, OnInit, ElementRef, OnDestroy } from '@angular/core';
+import * as i1 from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPValueWidgetComponent } from '@acorex-platform/framework-client/layout/widget-core';
+import * as i2 from '@angular/router';
+import { AXPBackgroundOperationHandler, AXPBackgroundOperation, AXPFileStorageService } from '@acorex-platform/framework-client/common';
+import * as _acorex_platform_framework_shared_core from '@acorex-platform/framework-shared/core';
+import { AXPExecuteCommand, AXPMultiLanguageString, AXPWidgetNode, AXPUserReference, AXPEntityReference } from '@acorex-platform/framework-shared/core';
+import { AXPDeviceService } from '@acorex-platform/framework-client/core';
+import { AXPPageLayoutBaseComponent } from '@acorex-platform/framework-client/layout/views';
+import * as _acorex_components_conversation from '@acorex/components/conversation';
+import { AXConversationApi, AXConversation, AXConversationMessageApi, AXConversationMessage, AXConversationRealtimeApi, AXConversationUserApi, AXConversationCreateData, AXConversationPagination, AXConversationFilters, AXConversationPaginatedResult, AXConversationUpdateData, AXConversationParticipant, AXConversationParticipantUpdate, AXConversationSettingsUpdate, AXConversationSendMessageCommand, AXConversationMessagePayload, AXConversationMessageSearchFilters, AXConversationReadReceipt, AXConversationMessageForwardData, AXConversationPinnedMessage, AXConversationConnectionStatus, AXConversationConnectionOptions, AXConversationConnectionEvent, AXConversationTypingIndicator, AXConversationNotificationEvent, AXConversationCallEvent, AXConversationUserProfileUpdate, AXConversationUserSearchFilters, AXConversationPresenceUpdate, AXConversationPresenceStatus, AXConversationBlockReportReason, AXConversationTab, AXConversationService } from '@acorex/components/conversation';
+import { AXMConversationRoom, AXMConversationMessage, AXMCommentEntityData, AXReaction, AXMessagePayload, AXMReactionType } from '@acorex-platform/module-conversation-client/contracts';
+import { Observable } from 'rxjs';
+import { AXClickEvent, AXStyleLookType, AXPlacement } from '@acorex/cdk/common';
+import { AXPAiChatResponse, AXPAiChatMessage, AXPAiChatFollowUpItem } from '@acorex-platform/module-ai-management-client';
+import { AXPEntityDefinitionRegistryService, AXPEntityActionPlugin } from '@acorex-platform/framework-client/layout/entity';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { AXWysiwygContainerComponent } from '@acorex/components/wysiwyg';
+import { AXPCommand, AXPCommandExecuteResultPromise } from '@acorex-platform/framework-shared/runtime';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXPWidgetConfig } from '@acorex-platform/framework-shared/widget-core';
+
+declare class AXMConversationModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMConversationModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMConversationModule, never, [typeof i1.AXPWidgetCoreModule], [typeof i2.RouterModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMConversationModule>;
+}
+
+declare const AXM_CONVERSATION_ASSIST_BACKGROUND_OPERATION_KEY = "conversation-ai-assist";
+
+declare class AXMConversationAssistBackgroundOperationHandler extends AXPBackgroundOperationHandler {
+    readonly providerKey = "conversation-ai-assist";
+    private readonly router;
+    private readonly chatService;
+    private readonly sessionService;
+    private readonly activatedRoute;
+    execute(command: AXPExecuteCommand, operation: AXPBackgroundOperation): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMConversationAssistBackgroundOperationHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMConversationAssistBackgroundOperationHandler>;
+}
+declare const AXM_CONVERSATION_ASSIST_BACKGROUND_OPERATION_HANDLERS: Provider[];
+
+declare class AXMChatComponent extends AXPPageLayoutBaseComponent {
+    #private;
+    private readonly conversationService;
+    private readonly chatConversationApi;
+    private readonly assistResponse;
+    private readonly miniChatPanelService;
+    private readonly composerService;
+    private readonly infoBarService;
+    /** Eagerly resolves tenant debug mode for assist debug download action visibility. */
+    private readonly _assistChatDebugModeInit;
+    private readonly activatedRoute;
+    private readonly dialogService;
+    private readonly popupService;
+    private readonly badgeService;
+    protected readonly deviceService: AXPDeviceService;
+    private readonly routeConversationId;
+    ngOnInit(): Promise<void>;
+    /**
+     * Computed signal to check if there is an active conversation selected.
+     */
+    readonly hasActiveConversation: _angular_core.Signal<boolean>;
+    readonly showChatList: _angular_core.Signal<boolean>;
+    /**
+     * Unread messages in other chats (excludes the open conversation), for the mobile back control.
+     */
+    readonly backBadgeCount: _angular_core.Signal<number>;
+    /**
+     * Handles conversation selection from the sidebar.
+     * Navigates to the selected conversation route.
+     * On mobile, closes the sidebar after selection.
+     * @param conversationId - The ID of the selected conversation.
+     */
+    onConversationSelected(conversationId: string): void;
+    /**
+     * Navigates back to the conversation list (mobile view).
+     * Removes the route param and clears the active conversation.
+     * Opens the sidebar to show the conversation list.
+     */
+    openChatList(): void;
+    /**
+     * Opens the platform conversation info panel when the info-bar title/avatar area is clicked.
+     */
+    onInfoBarClick(): void;
+    /** Composer Stop — abort server-side assist generation and SSE stream updates. */
+    onComposerGenerationCancelled(): void;
+    /**
+     * Handles Escape key from chat container.
+     * Replicates conversation source behavior by closing active conversation here.
+     * Also keeps URL and chat state in sync.
+     */
+    onContainerEscape(): void;
+    /**
+     * Toggles the start side (sidebar) visibility.
+     */
+    protected toggleStartSide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMChatComponent, "axm-chat", never, {}, {}, never, never, true, never>;
+}
+
+/** refType for multimedia attachments sent from conversation chat. */
+declare const AXM_CONVERSATION_CHAT_ATTACHMENT_REF_TYPE: string;
+/** File storage category for conversation chat attachments. */
+declare const AXM_CONVERSATION_CHAT_ATTACHMENT_CATEGORY = "chat-attachment";
+/**
+ * Persists a chat attachment; {@link refId} is typically the conversation id (batch grouping for multi-send).
+ */
+declare function persistChatAttachment(fileStorage: AXPFileStorageService, file: File, refId: string): Promise<{
+    fileId: string;
+}>;
+
+/** User profile, discovery, and presence for conversation chat. */
+declare abstract class AXMChatUserApi extends AXConversationUserApi {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatUserApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatUserApi>;
+}
+/** Conversation CRUD, participants, and inbox for conversation chat. */
+declare abstract class AXMChatConversationApi extends AXConversationApi {
+    /** Reports which conversation thread is open in chat UI (mock uses this for notifications). */
+    reportFocusedConversation(_conversationId: string | null): void;
+    /**
+     * Returns every conversation bound to the given entity reference (entity-scoped mini chats).
+     * Bypasses the regular inbox filtering so entity chats remain discoverable per entity.
+     */
+    abstract findEntityConversations(entityType: string, entityId: string): Promise<AXConversation[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatConversationApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatConversationApi>;
+}
+/** Message CRUD, reactions, and assist replies for conversation chat. */
+declare abstract class AXMChatMessageApi extends AXConversationMessageApi {
+    /**
+     * Re-runs AI generation for an incomplete or failed assist placeholder.
+     * Reuses the same message id so the conversation timeline stays ordered.
+     */
+    abstract retryAssistResponse(conversationId: string, messageId: string): Promise<AXConversationMessage>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatMessageApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatMessageApi>;
+}
+/** Realtime streams (messages, typing, presence) for conversation chat. */
+declare abstract class AXMChatRealtimeApi extends AXConversationRealtimeApi {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatRealtimeApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatRealtimeApi>;
+}
+
+/**
+ * Entity-backed implementation of {@link AXMChatConversationApi} using Conversation.room.
+ */
+declare class AXMChatEntityConversationApi extends AXMChatConversationApi {
+    private readonly entityService;
+    private readonly filterService;
+    private readonly userApi;
+    private readonly conversationStore;
+    private readonly realtimeBus;
+    private readonly focusHandler;
+    private readonly roomQuery;
+    private readonly roomData;
+    reportFocusedConversation(conversationId: string | null): void;
+    private publishConversationPatch;
+    private resolveParticipantsForCreate;
+    private toParticipantRole;
+    createConversation(data: AXConversationCreateData): Promise<AXConversation>;
+    getConversation(conversationId: string): Promise<AXConversation>;
+    getConversations(pagination: AXConversationPagination, filters?: AXConversationFilters): Promise<AXConversationPaginatedResult<AXConversation>>;
+    updateConversation(conversationId: string, updates: AXConversationUpdateData): Promise<AXConversation>;
+    deleteConversation(conversationId: string): Promise<boolean>;
+    private publishConversationById;
+    archiveConversation(conversationId: string): Promise<void>;
+    unarchiveConversation(conversationId: string): Promise<void>;
+    pinConversation(conversationId: string): Promise<void>;
+    unpinConversation(conversationId: string): Promise<void>;
+    markConversationAsRead(conversationId: string): Promise<void>;
+    markConversationAsUnread(conversationId: string): Promise<void>;
+    searchConversations(query: string): Promise<AXConversation[]>;
+    filterConversations(filters: AXConversationFilters, pagination?: AXConversationPagination): Promise<AXConversationPaginatedResult<AXConversation>>;
+    findEntityConversations(entityType: string, entityId: string): Promise<AXConversation[]>;
+    getParticipants(conversationId: string): Promise<AXConversationParticipant[]>;
+    addParticipants(conversationId: string, userIds: string[]): Promise<AXConversation>;
+    removeParticipant(conversationId: string, userId: string): Promise<AXConversation>;
+    leaveConversation(conversationId: string): Promise<void>;
+    updateParticipant(conversationId: string, update: AXConversationParticipantUpdate): Promise<AXConversation>;
+    getConversationSettings(conversationId: string): Promise<AXConversationSettingsUpdate>;
+    updateConversationSettings(conversationId: string, settings: AXConversationSettingsUpdate): Promise<void>;
+    muteConversation(conversationId: string, duration?: number): Promise<void>;
+    unmuteConversation(conversationId: string): Promise<void>;
+    uploadConversationAvatar(_conversationId: string, _file: File): Promise<string>;
+    getConversationMedia(_conversationId: string, pagination?: AXConversationPagination): Promise<AXConversationPaginatedResult<unknown>>;
+    addConversationTags(_conversationId: string, _tags: string[]): Promise<void>;
+    removeConversationTags(_conversationId: string, _tags: string[]): Promise<void>;
+    getConversationTags(_conversationId: string): Promise<string[]>;
+    saveDraft(conversationId: string, draft: string): Promise<void>;
+    getDraft(conversationId: string): Promise<string | null>;
+    clearDraft(conversationId: string): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatEntityConversationApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatEntityConversationApi>;
+}
+
+/**
+ * Focus subscription, realtime room subscribe, and read-state sync for the active conversation.
+ */
+declare class AXMChatEntityConversationFocusHandler {
+    private readonly userApi;
+    private readonly commandService;
+    private readonly focusService;
+    private readonly assistResponse;
+    private readonly realtimeConnection;
+    private subscribedConversationId;
+    private focusSyncTimer;
+    private pendingFocusConversationId;
+    reportFocusedConversation(conversationId: string | null): void;
+    private runFocusedConversationSync;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatEntityConversationFocusHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatEntityConversationFocusHandler>;
+}
+
+/**
+ * Room list loading and conversation mapping helpers for the entity conversation API.
+ */
+declare class AXMChatEntityConversationRoomQueryService {
+    private readonly entityService;
+    private readonly filterService;
+    private readonly userApi;
+    private readonly roomData;
+    private readonly messageData;
+    loadChatRooms(): Promise<AXMConversationRoom[]>;
+    enrichRoom(room: AXMConversationRoom, options?: {
+        probeLastMessage?: boolean;
+        currentUserId?: string;
+    }): Promise<AXConversation>;
+    paginate<T>(items: T[], pagination: AXConversationPagination): AXConversationPaginatedResult<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatEntityConversationRoomQueryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatEntityConversationRoomQueryService>;
+}
+
+/**
+ * Maps a persisted room entity to the conversation {@link AXConversation} contract.
+ */
+declare function axmRoomEntityToConversation(room: AXMConversationRoom, currentUserId?: string): AXConversation;
+/**
+ * Maps a persisted message entity to the conversation {@link AXConversationMessage} contract.
+ */
+declare function axmMessageEntityToMessage(message: AXMConversationMessage): AXConversationMessage;
+/**
+ * Maps a security-management user row to {@link AXConversationParticipant}.
+ */
+declare function axmUserRowToParticipant(user: {
+    id: string;
+    displayName?: string;
+    username?: string;
+}): AXConversationParticipant;
+
+/**
+ * Entity-backed implementation of {@link AXMChatMessageApi} using Conversation.message.
+ */
+declare class AXMChatEntityMessageApi extends AXMChatMessageApi {
+    #private;
+    private static readonly MESSAGE_QUERY_MAX;
+    private readonly entityService;
+    private readonly filterService;
+    private readonly userApi;
+    private readonly commandService;
+    private readonly assistResponse;
+    private readonly conversationStore;
+    private readonly realtime;
+    private readonly typingStopTimers;
+    private readonly messageData;
+    private readonly roomData;
+    private requireConversationParticipant;
+    private loadConversationMessages;
+    private paginateMessages;
+    private paginateAxMessages;
+    private mergePersistedMessages;
+    private touchConversationLastMessage;
+    sendMessage(command: AXConversationSendMessageCommand): Promise<AXConversationMessage>;
+    getMessage(messageId: string): Promise<AXConversationMessage>;
+    getMessages(conversationId: string, pagination: AXConversationPagination): Promise<AXConversationPaginatedResult<AXConversationMessage>>;
+    editMessage(messageId: string, payload: AXConversationMessagePayload): Promise<AXConversationMessage>;
+    deleteMessage(messageId: string, _forEveryone?: boolean): Promise<void>;
+    deleteMessages(messageIds: string[], forEveryone?: boolean): Promise<void>;
+    retryAssistResponse(conversationId: string, messageId: string): Promise<AXConversationMessage>;
+    searchMessages(conversationId: string, filters: AXConversationMessageSearchFilters, pagination?: AXConversationPagination): Promise<AXConversationPaginatedResult<AXConversationMessage>>;
+    searchAllMessages(filters: AXConversationMessageSearchFilters, pagination?: AXConversationPagination): Promise<AXConversationPaginatedResult<AXConversationMessage>>;
+    private persistReactionsAndPublish;
+    addReaction(messageId: string, emoji: string): Promise<void>;
+    removeReaction(messageId: string, emoji: string): Promise<void>;
+    getAvailableReactions(): Promise<string[]>;
+    markAsRead(conversationId: string, messageIds: string[]): Promise<void>;
+    markAsUnread(conversationId: string): Promise<void>;
+    getReadReceipts(_messageId: string): Promise<AXConversationReadReceipt[]>;
+    markMessagesAsRead(messageIds: string[]): Promise<void>;
+    forwardMessage(_data: AXConversationMessageForwardData): Promise<AXConversationMessage[]>;
+    pinMessage(conversationId: string, messageId: string): Promise<void>;
+    unpinMessage(conversationId: string, messageId: string): Promise<void>;
+    getPinnedMessages(conversationId: string): Promise<AXConversationPinnedMessage[]>;
+    getMessageReplies(messageId: string, pagination?: AXConversationPagination): Promise<AXConversationPaginatedResult<AXConversationMessage>>;
+    getReplyCount(messageId: string): Promise<number>;
+    getForwardCount(_messageId: string): Promise<number>;
+    sendTypingIndicator(conversationId: string): Promise<void>;
+    stopTypingIndicator(conversationId: string): Promise<void>;
+    updateMessageMetadata(messageId: string, metadata: Record<string, unknown>): Promise<void>;
+    getMessageMetadata(messageId: string): Promise<Record<string, unknown>>;
+    updateMessageStatus(messageId: string, status: 'sending' | 'sent' | 'delivered' | 'read' | 'failed'): Promise<void>;
+    getMessageDeliveryStatus(_messageId: string): Promise<{
+        delivered: number;
+        read: number;
+        total: number;
+    }>;
+    bulkDeleteMessages(conversationId: string, messageIds: string[], forEveryone?: boolean): Promise<void>;
+    exportMessages(_conversationId: string, _format: 'json' | 'csv' | 'txt'): Promise<string | Blob>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatEntityMessageApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatEntityMessageApi>;
+}
+
+/**
+ * Entity-backed realtime API that forwards {@link AXMConversationRealtimeBus} events to conversation.
+ */
+declare class AXMChatEntityRealtimeApi extends AXMChatRealtimeApi {
+    private readonly bus;
+    private readonly realtimeConnection;
+    private readonly presence;
+    readonly connectionStatus$: Observable<AXConversationConnectionStatus>;
+    connect(_options?: AXConversationConnectionOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    reconnect(): Promise<void>;
+    subscribeToConnectionEvents(): Observable<AXConversationConnectionEvent>;
+    subscribeToMessages(conversationId: string): Observable<AXConversationMessage>;
+    subscribeToMessageUpdates(conversationId?: string): Observable<AXConversationMessage>;
+    subscribeToMessageDeletions(_conversationId?: string): Observable<string>;
+    subscribeToMessageReactions(conversationId?: string): Observable<AXConversationMessage>;
+    subscribeToConversationUpdates(): Observable<AXConversation>;
+    subscribeToConversationCreated(): Observable<AXConversation>;
+    subscribeToConversationDeleted(): Observable<string>;
+    subscribeToTypingIndicators(conversationId: string): Observable<AXConversationTypingIndicator>;
+    subscribeToPresenceUpdates(userIds?: string[]): Observable<_acorex_components_conversation.AXConversationPresenceUpdate>;
+    subscribeToReadReceipts(conversationId?: string): Observable<{
+        messageId: string;
+        userId: string;
+        readAt: Date;
+    }>;
+    subscribeToNotifications(): Observable<AXConversationNotificationEvent>;
+    subscribeToCallEvents(): Observable<AXConversationCallEvent>;
+    subscribeToUserBlockEvents(): Observable<{
+        userId: string;
+        blocked: boolean;
+    }>;
+    subscribeToParticipantEvents(_conversationId?: string): Observable<{
+        conversationId: string;
+        userId: string;
+        action: 'added' | 'removed';
+    }>;
+    subscribeToSystemEvents(): Observable<{
+        type: string;
+        message: string;
+        data?: unknown;
+    }>;
+    subscribeToMessageStatusChanges(conversationId?: string): Observable<{
+        messageId: string;
+        status: 'sending' | 'sent' | 'delivered' | 'read' | 'failed';
+        timestamp: Date;
+    }>;
+    subscribeToConversationSettingsChanges(_conversationId?: string): Observable<{
+        conversationId: string;
+        settings: Record<string, unknown>;
+    }>;
+    subscribeToDraftChanges(_conversationId?: string): Observable<{
+        conversationId: string;
+        draft: string | null;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatEntityRealtimeApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatEntityRealtimeApi>;
+}
+
+/**
+ * Entity-backed implementation of {@link AXMChatUserApi} using SecurityManagement.User.
+ */
+declare class AXMChatEntityUserApi extends AXMChatUserApi {
+    private readonly sessionService;
+    private readonly filterService;
+    private readonly entityService;
+    private readonly usersData;
+    private readonly presence;
+    getCurrentUser(): Promise<AXConversationParticipant>;
+    updateProfile(updates: AXConversationUserProfileUpdate): Promise<AXConversationParticipant>;
+    uploadAvatar(_file: File): Promise<string>;
+    getUsers(pagination?: AXConversationPagination, filters?: AXConversationUserSearchFilters): Promise<AXConversationPaginatedResult<AXConversationParticipant>>;
+    searchUsers(query: string): Promise<AXConversationParticipant[]>;
+    getUserById(userId: string): Promise<AXConversationParticipant>;
+    getUsersByIds(userIds: string[]): Promise<AXConversationParticipant[]>;
+    getUserPresence(userId: string): Promise<AXConversationPresenceUpdate>;
+    updatePresence(status: AXConversationPresenceStatus, _statusText?: string): Promise<void>;
+    blockUser(_userId: string, _reason?: AXConversationBlockReportReason): Promise<void>;
+    unblockUser(_userId: string): Promise<void>;
+    getBlockedUsers(): Promise<string[]>;
+    reportUser(_userId: string, _reason: AXConversationBlockReportReason): Promise<void>;
+    getUserSettings(): Promise<Record<string, unknown>>;
+    updateUserSettings(_settings: Record<string, unknown>): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMChatEntityUserApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMChatEntityUserApi>;
+}
+
+interface AXMAssistDefaultResolverPort {
+    getDefaultAssistId(): Promise<string | undefined>;
+}
+declare const AXM_ASSIST_DEFAULT_RESOLVER_PORT: InjectionToken<AXMAssistDefaultResolverPort>;
+
+interface AXMChatSidebarAction {
+    id: string;
+    label: string;
+    icon: string;
+    priority?: number;
+    run(event?: AXClickEvent): Promise<AXConversation | null | void> | AXConversation | null | void;
+}
+declare const AXM_CHAT_SIDEBAR_ACTION_PROVIDER: InjectionToken<AXMChatSidebarAction[]>;
+
+/** True when the conversation is an assist / AI bot chat. */
+declare function axmIsAssistBotConversation(conversation: AXConversation): boolean;
+/** Sidebar tab for AI assist conversations (`type: 'bot'` or assist metadata). */
+declare const AXM_CONVERSATION_TAB_BOT: AXConversationTab;
+
+declare const AXM_CHAT_EMPTY_STATE_COMPONENT: InjectionToken<Type<unknown>>;
+
+interface AXPAiChatFollowUpCommandLite {
+    name: string;
+    options?: unknown;
+}
+interface AXPAiChatFollowUpItemLite {
+    text: string | AXPMultiLanguageString;
+    command: AXPAiChatFollowUpCommandLite;
+}
+interface AXPAiChatTextResponseLite {
+    type: 'text';
+    content: string;
+}
+interface AXPAiChatNodeOrFollowUpResponseLite {
+    type: 'node' | 'followUp';
+    content: unknown;
+}
+interface AXPAiChatMessageLite {
+    role: 'assistant' | 'user' | 'tool';
+    responses: Array<AXPAiChatTextResponseLite | AXPAiChatNodeOrFollowUpResponseLite>;
+}
+interface AXPAiEffectiveAssistRowLite {
+    id: string;
+    name?: string;
+    title?: AXPMultiLanguageString | string;
+    description?: AXPMultiLanguageString | string;
+    professionImageUrl?: string;
+    initialMessages?: string | null;
+    starterPrompts?: Array<{
+        text?: string | AXPMultiLanguageString | null;
+    }> | null;
+    modelId?: string | null;
+}
+/** Persisted on conversation.room metadata to avoid Assist GetById on chat open. */
+interface AXMAssistConversationSnapshotLite {
+    initialMessages?: string | null;
+    starterPrompts?: Array<{
+        text?: string | AXPMultiLanguageString | null;
+    }> | null;
+    modelId?: string | null;
+}
+
+/**
+ * Assist suggestion chips (starter prompts and engine {@code followUp} segments).
+ * Each item runs its platform command via {@link AXPCommandService}.
+ */
+declare class AXMAssistSuggestionChipsComponent {
+    readonly items: _angular_core.InputSignal<AXPAiChatFollowUpItemLite[]>;
+    /** Tighter chip layout for mini-chat and other narrow panels. */
+    readonly compact: _angular_core.InputSignal<boolean>;
+    /** When true, sends starter prompts via the local {@link AXConversationService} instead of routing to chat. */
+    readonly sendInPlace: _angular_core.InputSignal<boolean>;
+    /** Disables all chips (e.g. parent composer is loading or sending). */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Emits when an in-place send creates a new conversation (mini chat empty state). */
+    readonly conversationCreated: _angular_core.OutputEmitterRef<string>;
+    protected readonly normalizedItems: _angular_core.Signal<AXPAiChatFollowUpItemLite[]>;
+    private readonly busy;
+    protected readonly isInteractionBlocked: _angular_core.Signal<boolean>;
+    private readonly commandService;
+    private readonly conversationService;
+    private readonly conversationApi;
+    private readonly entityChatService;
+    private readonly assistCatalog;
+    private readonly translationService;
+    private readonly layoutTheme;
+    protected onChipClick(item: AXPAiChatFollowUpItemLite): Promise<void>;
+    protected resolveChipLabel(item: AXPAiChatFollowUpItemLite): string;
+    private isSendAssistChatMessageCommand;
+    private resolveItemText;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAssistSuggestionChipsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMAssistSuggestionChipsComponent, "axm-assist-suggestion-chips", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "sendInPlace": { "alias": "sendInPlace"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "conversationCreated": "conversationCreated"; }, never, never, true, never>;
+}
+
+type AssistStarterPromptsSource = {
+    starterPrompts?: Array<{
+        text?: string | Record<string, string> | null;
+    }> | null;
+} | Pick<AXPAiEffectiveAssistRowLite, 'starterPrompts'> | null | undefined;
+interface AXMAssistStarterPromptChipOptions {
+    assistId?: string;
+    conversationId?: string;
+    /** When `false`, the chip command sends the message without routing to the chat app (e.g. mini chat). */
+    navigate?: boolean;
+    /** Entity reference so a chip-created conversation stays bound to its entity (mini chat). */
+    entityId?: string;
+    entityType?: string;
+}
+/**
+ * Resolves a follow-up chip command for Conversation assist.
+ * AI follow-up output may use invalid `Registry:*` placeholders; those map to
+ * {@link CONVERSATION_SEND_ASSIST_CHAT_MESSAGE_COMMAND} so the chip text is sent as the next user message.
+ */
+declare function axmAssistResolveFollowUpCommandName(rawName: string, commandExists: (name: string) => boolean): string;
+/** Rewrites invalid follow-up commands (e.g. hallucinated `Registry:*` keys) before rendering chips. */
+declare function axmAssistNormalizeFollowUpItemForConversation(item: AXPAiChatFollowUpItemLite): AXPAiChatFollowUpItemLite;
+declare function axmAssistNormalizeFollowUpItemsForConversation(items: AXPAiChatFollowUpItemLite[]): AXPAiChatFollowUpItemLite[];
+/**
+ * Maps assist starter prompts to follow-up chip items that run {@link CONVERSATION_SEND_ASSIST_CHAT_MESSAGE_COMMAND}.
+ */
+declare function axmAssistStarterPromptChipItems(source: AssistStarterPromptsSource, options?: AXMAssistStarterPromptChipOptions): AXPAiChatFollowUpItemLite[];
+
+/**
+ * Temporary AI module identifiers used by conversation while AI-specific UI
+ * is being extracted to the conversation AI extension.
+ */
+declare const AXM_AI_MANAGEMENT_MODULE_NAME = "AiManagement";
+declare const AXM_AI_MANAGEMENT_ASSIST_ENTITY_NAME = "Assist";
+declare const AXM_AI_MANAGEMENT_AGENT_ENTITY_NAME = "AiAgent";
+
+interface AXMSendAssistChatMessageOptions {
+    text: string;
+    conversationId?: string;
+    assistId?: string;
+    targetId?: string;
+    navigate?: boolean;
+    entityId?: string;
+    entityType?: string;
+}
+
+/**
+ * Reorders assist transcript for debug UI: think first, tool/agent + tool results, then text blocks.
+ */
+declare function axmNormalizeAssistTranscriptForChatUi(input: AXPAiChatMessage[]): AXPAiChatMessage[];
+/** Debug transcript from {@code metadata.transcripts} or streaming {@code metadata.transcriptDraft}. */
+declare function axmReadAssistAiTranscript(metadata: unknown): AXPAiChatMessage[] | null;
+/** Raw engine transcript (chronological), without debug UI reordering. */
+declare function axmReadAssistAiTranscriptRaw(metadata: unknown): AXPAiChatMessage[];
+declare function axmAssistWidgetNodeFromUnknown(content: unknown, depth?: number): AXPWidgetNode | null;
+/** Stable identity for widget nodes so embedded JSON vs structured `node` segments dedupe despite key order. */
+declare function axmAssistWidgetNodeDedupeKey(content: unknown): string;
+declare function axmSyntheticEmbedMessage(parent: AXConversationMessage, suffix: string, partial: Pick<AXConversationMessage, 'type' | 'payload'>): AXConversationMessage;
+declare const AXM_ASSIST_TRANSCRIPT_LINE_PAYLOAD_TYPE: "assist-transcript-line";
+interface AxmAssistTranscriptLinePayload {
+    type: typeof AXM_ASSIST_TRANSCRIPT_LINE_PAYLOAD_TYPE;
+    line: AXPAiChatMessage;
+}
+declare function axmNormalizeAssistTranscriptLineResponses(line: AXPAiChatMessage): AXPAiChatMessage;
+/** Last {@link AXPAiChatMessage} in the engine turn (index {@code length - 1}). */
+declare function axmAssistLastTranscriptLine(transcript: AXPAiChatMessage[]): AXPAiChatMessage | null;
+interface AxmAssistPartitionedAnswerText {
+    markdown: string;
+    renderable: AXPAiChatResponse[];
+}
+/**
+ * Splits user-facing markdown from embedded {@code node}/{@code followUp} JSON so widgets render after text.
+ */
+declare function axmPartitionAssistAnswerText(raw: string): AxmAssistPartitionedAnswerText;
+/** Removes embedded {@code node}/{@code followUp}/aggregate JSON from answer markdown (stream + finalize). */
+declare function axmSanitizeAssistUserAnswerText(raw: string): string;
+/**
+ * Merges streamed answer markdown with transcript-derived text so finalize does not drop interim narration.
+ */
+declare function axmResolveAssistFinalAnswerText(streamDraft: string, transcriptAnswer: string): string;
+/** Replaces the payload line's text segment with the finalized answer markdown. */
+declare function axmApplyAnswerTextToAssistPayloadLine(line: AXPAiChatMessage, answerText: string): AXPAiChatMessage;
+/**
+ * User-facing payload line for the assist bubble: supervisor markdown narration for the turn, plus
+ * {@code node}/{@code file}/{@code followUp} from the turn (including specialist {@code agent_result}).
+ */
+declare function axmAssistUserFacingPayloadLine(transcript: AXPAiChatMessage[]): AXPAiChatMessage | null;
+declare function axmBuildAssistTranscriptLinePayload(line: AXPAiChatMessage): AxmAssistTranscriptLinePayload;
+declare function axmParseAssistTranscriptLinePayload(payload: unknown): AXPAiChatMessage | null;
+/** Reads finalized `{ type: 'text' }` assist payloads for markdown rendering. */
+declare function axmReadPlainTextMessagePayload(payload: unknown): string;
+declare function axmParseAssistTranscriptTextEnvelope(raw: string): {
+    thinking: string | null;
+    body: string;
+};
+/** Flattened user-visible items for one transcript line (payload bubble). */
+type AxmAssistUserVisibleItem = {
+    kind: 'text';
+    content: string;
+} | {
+    kind: 'node';
+    content: unknown;
+} | {
+    kind: 'file';
+    fileId: string;
+    isDownloadable?: boolean;
+} | {
+    kind: 'followUp';
+    items: AXPAiChatFollowUpItem[];
+};
+declare function axmAssistUserVisibleItemsForLine(line: AXPAiChatMessage): AxmAssistUserVisibleItem[];
+/** Parses a raw {@code followUp} segment for UI (normalizes chip commands). */
+declare function axmAssistFollowUpItemsFromUnknown(raw: unknown): AXPAiChatFollowUpItem[];
+
+/**
+ * Resolves assist id from conversation metadata.
+ */
+declare function axmExtractAssistIdFromMetadata(metadata: Record<string, unknown> | undefined): string | undefined;
+/**
+ * Resolves direct agent id from conversation metadata (agent-as-assist chat).
+ */
+declare function axmExtractDirectAgentIdFromMetadata(metadata: Record<string, unknown> | undefined): string | undefined;
+/** True when the conversation targets an assist catalog row or a direct agent-as-assist chat. */
+declare function axmConversationHasAiChat(metadata: Record<string, unknown> | undefined): boolean;
+/** Reads embedded assist welcome/model fields stamped at conversation create. */
+declare function axmExtractAssistSnapshotFromMetadata(metadata: Record<string, unknown> | undefined): AXMAssistConversationSnapshotLite | null;
+/** Resolves model entity id from conversation metadata (snapshot or persisted patch). */
+declare function axmExtractModelEntityIdFromMetadata(metadata: Record<string, unknown> | undefined): string | undefined;
+
+/**
+ * True when the participant is an AI Assist peer (synthetic `assist-*` id or assist metadata).
+ * Such entries should not appear in human-only pickers (e.g. regular "New chat").
+ */
+declare function axmIsAssistPeerParticipant(participant: AXConversationParticipant): boolean;
+/**
+ * Builds a synthetic assist peer for entity-backed room creation when the id is not a security user.
+ */
+declare function axmBuildAssistPeerParticipantFromCreateData(participantId: string, data: AXConversationCreateData): AXConversationParticipant | null;
+/**
+ * Minimal assist peer for lookups by synthetic `assist-*` participant id.
+ */
+declare function axmBuildAssistPeerParticipantFromId(participantId: string): AXConversationParticipant | null;
+
+/** Persisted on assist message metadata (`assistResponseStatus`). */
+type AxmAssistResponseStatus = 'streaming' | 'complete' | 'incomplete' | 'failed';
+/**
+ * Resolves assist response lifecycle from message metadata.
+ * Falls back to legacy `isStreaming` when `assistResponseStatus` is absent.
+ */
+declare function axmReadAssistResponseStatus(metadata: unknown): AxmAssistResponseStatus;
+/** User-facing error stored when generation fails (`assistResponseError`). */
+declare function axmReadReplyToUserMessageId(metadata: unknown): string | undefined;
+declare function axmReadAssistResponseError(metadata: unknown): string | undefined;
+declare function axmIsAssistRetryableStatus(status: AxmAssistResponseStatus): boolean;
+declare function axmIsAssistStreamingStatus(status: AxmAssistResponseStatus): boolean;
+declare function axmIsAssistTerminalStatus(status: AxmAssistResponseStatus): boolean;
+/** Finalize metadata persisted when a run completes (even if status lags). */
+declare function axmAssistHasFinalizeMetadata(metadata: unknown): boolean;
+/** Persisted terminal assist state should win over stale in-memory streaming cache. */
+declare function axmShouldPreferPersistedAssistOverLiveCache(persisted: {
+    metadata?: unknown;
+}, live: {
+    metadata?: unknown;
+}): boolean;
+/**
+ * True when a row is still marked `streaming` but already contains a finished assist reply
+ * (e.g. finalize persisted payload but not status, or the page reloaded before terminal persist).
+ *
+ * Do not treat live `streamDraftText` (or draft mirrored into `payload.text` for display) as complete.
+ */
+declare function axmAssistPersistedMessageLooksComplete(message: {
+    payload?: unknown;
+    metadata?: unknown;
+}): boolean;
+
+/**
+ * True while an assist placeholder is still generating (not yet a deliverable reply).
+ */
+declare function axmIsAssistStreamingMessage(message: AXConversationMessage): boolean;
+/**
+ * Whether an incoming message should increase the conversation unread counter.
+ */
+declare function axmMessageCountsTowardUnread(message: AXConversationMessage, currentUserId: string): boolean;
+/** Recomputes unread badge count from persisted messages. */
+declare function axmComputeConversationUnreadCount(messages: AXConversationMessage[], currentUserId: string): number;
+
+declare function axmCoerceTimestampMs(value: unknown): number;
+/** Coerces entity / IndexedDB values to {@link Date} for conversation UI sorting. */
+declare function axmCoerceDate(value: unknown): Date;
+declare function axmSortMessagesNewestFirst(messages: AXConversationMessage[]): AXConversationMessage[];
+
+/** Row shown in Conversation “Chat with AI” pickers (catalog assist). */
+interface AXMChatAiTargetRow {
+    id: string;
+    name: string;
+    title: AXPMultiLanguageString | string;
+    description?: AXPMultiLanguageString | string;
+    professionImageUrl?: string;
+}
+/** Synthetic bot participant id for assist chats. */
+declare function axmChatAiPeerParticipantId(catalogId: string): string;
+/** Conversation metadata for starting an AI chat from a picker row. */
+declare function axmBuildAiChatConversationMetadata(row: AXMChatAiTargetRow, assistSnapshot?: AXMAssistConversationSnapshotLite): Record<string, unknown>;
+/** Loads assist rows for Conversation AI chat pickers. */
+declare function axmLoadChatAiTargets(entityRegistry: AXPEntityDefinitionRegistryService): Promise<AXMChatAiTargetRow[]>;
+/** Resolves ML or plain string for search/display. */
+declare function axmResolveChatAiTargetText(resolveMl: (value: AXPMultiLanguageString) => string | undefined, value: AXPMultiLanguageString | string | undefined): string;
+declare function axmChatAiTargetDisplayName(resolveMl: (value: AXPMultiLanguageString) => string | undefined, row: AXMChatAiTargetRow): string;
+declare function axmChatAiTargetDisplayDescription(resolveMl: (value: AXPMultiLanguageString) => string | undefined, row: AXMChatAiTargetRow): string | undefined;
+declare function axmChatAiTargetAvatarUrl(row: AXMChatAiTargetRow): string | null;
+/** Fallback i18n key for rows with no catalog description. */
+declare function axmChatAiTargetShortcutDescriptionKey(): string;
+/** Same filter as {@link AXMChatWithAssistDialogComponent} target list search. */
+declare function axmFilterChatAiTargets(resolveMl: (value: AXPMultiLanguageString) => string | undefined, rows: AXMChatAiTargetRow[], query: string): AXMChatAiTargetRow[];
+
+/** Builds a sidebar/header title from the first user message (heuristic fallback). */
+declare function axmBuildAutoTitleFromUserText(raw: string): string | null;
+/** Bot/assist list rows often show the assist peer `name` — keep it in sync with room title. */
+declare function axmSyncAssistPeerDisplayName<T extends Pick<AXConversation, 'title' | 'participants'>>(conversation: T): T;
+declare function axmRoomWithAssistPeerDisplayName(room: AXMConversationRoom): AXMConversationRoom;
+
+interface AXMConversationAssistResponsePort {
+    handleAfterUserMessage(conversationId: string, userMessageId: string, command: AXConversationSendMessageCommand, currentUserId: string): Promise<void>;
+    retryAssistResponse(conversationId: string, messageId: string): Promise<AXConversationMessage>;
+    reconcileStaleAssistPlaceholders(conversationId?: string): Promise<void>;
+    /** True when the conversation has assist rows still marked streaming (cache or entity). */
+    hasStreamingAssistPlaceholders(conversationId: string): Promise<boolean>;
+    /** Latest in-memory assist row (streaming cache wins over entity reads). */
+    getLiveMessage(messageId: string): AXConversationMessage | null;
+    /** Merges assist in-memory cache over persisted messages (mock `conversationSharedStorage.messages` parity). */
+    mergeLiveConversationMessages(conversationId: string, persisted: AXConversationMessage[]): AXConversationMessage[];
+    /** Aligns composer Stop / spinner with assist streaming for the focused conversation. */
+    syncComposerGenerationForFocus(conversationId: string | null): Promise<void>;
+    /** Cancels in-flight assist generation (composer Stop). Aborts server AI + SSE stream updates. */
+    cancelAssistGeneration(conversationId: string): Promise<void>;
+}
+declare const AXM_CONVERSATION_ASSIST_RESPONSE_PORT: InjectionToken<AXMConversationAssistResponsePort>;
+
+interface AXMConversationRegularAutoReplyPort {
+    maybeGenerate(command: AXConversationSendMessageCommand, userMessageId: string, currentUserId: string): Promise<void>;
+}
+declare const AXM_CONVERSATION_REGULAR_AUTO_REPLY_PORT: InjectionToken<AXMConversationRegularAutoReplyPort>;
+
+/**
+ * Entity-backed read/write facade for chat rooms and messages.
+ * Publishes mutations to {@link AXMConversationRealtimeBus}.
+ */
+declare class AXMConversationEntityStoreService {
+    private readonly entityService;
+    private readonly filterService;
+    private readonly bus;
+    private readonly messageData;
+    private readonly roomData;
+    /** Serializes entity writes per message id so streaming deltas persist in order. */
+    private readonly persistChains;
+    /** Avoids GET-by-id existence probes for assist rows already written in this session. */
+    private readonly persistedMessageIds;
+    /** In-memory snapshots to avoid redundant GetById after local writes. */
+    private readonly conversationCache;
+    private readonly messageCache;
+    private readonly messageListCache;
+    /** Dedupes concurrent room GetById for the same conversation. */
+    private readonly conversationFetchChains;
+    /** Dedupes concurrent message list queries (page 0). */
+    private readonly messageListFetchChains;
+    getCachedConversation(conversationId: string): AXConversation | null;
+    getCachedMessageList(conversationId: string): AXConversationMessage[] | null;
+    cacheConversation(conversation: AXConversation): void;
+    cacheConversationFromRoom(room: AXMConversationRoom, currentUserId?: string): AXConversation;
+    getConversation(conversationId: string, options?: {
+        force?: boolean;
+    }): Promise<AXConversation | null>;
+    private fetchConversationFromEntity;
+    /** Persists auto-generated title after assist completes (never during streaming). */
+    persistAssistTitlePatch(room: AXMConversationRoom): Promise<void>;
+    getMessage(messageId: string): Promise<AXConversationMessage | null>;
+    cacheMessage(message: AXConversationMessage): void;
+    getCachedMessage(messageId: string): AXConversationMessage | null;
+    invalidateMessageListCache(conversationId: string): void;
+    cacheEmptyMessageList(conversationId: string): void;
+    private patchMessageListCache;
+    private appendToMessageListCache;
+    loadConversationMessages(conversationId: string, options?: {
+        skip?: number;
+        take?: number;
+        force?: boolean;
+    }): Promise<AXConversationMessage[]>;
+    private queryConversationMessages;
+    /** Assist placeholders still marked `streaming` in entity storage (e.g. after page reload). */
+    loadStreamingAssistPlaceholderMessages(conversationId?: string): Promise<AXConversationMessage[]>;
+    createMessageFromAxMessage(message: AXConversationMessage): Promise<AXConversationMessage>;
+    createMessageWithId(message: AXConversationMessage): Promise<AXConversationMessage>;
+    updateMessage(message: AXConversationMessage, options?: {
+        publish?: boolean;
+    }): Promise<AXConversationMessage>;
+    /**
+     * Persists a message to entity storage without publishing realtime events.
+     * Matches mock `putMessage` fire-and-forget used during assist streaming.
+     */
+    persistMessage(message: AXConversationMessage): Promise<void>;
+    private persistMessageInternal;
+    deleteMessage(messageId: string): Promise<void>;
+    touchLastMessage(conversationId: string, message: AXConversationMessage): Promise<void>;
+    updateConversation(conversation: AXConversation): Promise<AXConversation>;
+    updateConversationMetadata(conversationId: string, metadata: Record<string, unknown>): Promise<void>;
+    setUnreadCount(conversationId: string, unreadCount: number): Promise<void>;
+    syncConversationUnreadCount(conversationId: string, currentUserId: string): Promise<void>;
+    private isAssistResponseEntity;
+    messageToEntityFields(message: AXConversationMessage): Partial<AXMConversationMessage>;
+    axMessageFromCommand(command: AXConversationSendMessageCommand, senderId: string): AXConversationMessage;
+    publishNewMessage(message: AXConversationMessage): void;
+    publishMessageUpdate(message: AXConversationMessage): void;
+    publishConversationUpdate(conversation: AXConversation): void;
+    publishConversationCreated(conversation: AXConversation): void;
+    publishTypingIndicator(indicator: _acorex_components_conversation.AXConversationTypingIndicator): void;
+    publishPresenceUpdate(update: _acorex_components_conversation.AXConversationPresenceUpdate): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMConversationEntityStoreService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMConversationEntityStoreService>;
+}
+
+/**
+ * Tracks which conversation is focused in the chat UI and applies read-state updates.
+ */
+declare class AXMConversationFocusService {
+    private readonly store;
+    private focusedConversationId;
+    /** Reactive focus id for computed UI (retry screen, etc.). */
+    readonly focusedConversationIdSignal: _angular_core.WritableSignal<string | null>;
+    setFocusedConversation(conversationId: string | null): void;
+    isFocused(conversationId: string): boolean;
+    getFocusedConversationId(): string | null;
+    /**
+     * Marks incoming messages as read when the conversation is focused.
+     * Returns ids that were transitioned to `read`.
+     */
+    markMessagesRead(conversationId: string, messageIds: readonly string[], currentUserId: string): Promise<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMConversationFocusService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMConversationFocusService>;
+}
+
+/**
+ * In-memory event bus for entity-backed chat realtime updates.
+ * Replaces {@link conversationSharedStorage} streams for the conversation module.
+ */
+declare class AXMConversationRealtimeBus {
+    private readonly connectionStatusSubject;
+    readonly connectionStatus$: Observable<AXConversationConnectionStatus>;
+    private readonly messageStreamSubject;
+    private readonly messageUpdateSubject;
+    private readonly messageDeletionSubject;
+    readonly messageStream$: Observable<AXConversationMessage>;
+    readonly messageUpdates$: Observable<AXConversationMessage>;
+    readonly messageDeletions$: Observable<string>;
+    private readonly conversationUpdateSubject;
+    private readonly conversationCreatedSubject;
+    readonly conversationUpdates$: Observable<AXConversation>;
+    readonly conversationCreated$: Observable<AXConversation>;
+    private readonly typingIndicatorSubject;
+    private readonly presenceUpdateSubject;
+    readonly typingIndicators$: Observable<AXConversationTypingIndicator>;
+    readonly presenceUpdates$: Observable<AXConversationPresenceUpdate>;
+    setConnectionStatus(status: AXConversationConnectionStatus): void;
+    publishMessage(message: AXConversationMessage): void;
+    publishMessageUpdate(message: AXConversationMessage): void;
+    publishMessageDeletion(messageId: string): void;
+    /** Suppresses redundant room GetById after a client-originated publish (entity-mutation echo). */
+    private readonly recentLocalRoomMutations;
+    private static readonly LOCAL_ROOM_MUTATION_SUPPRESS_MS;
+    markLocalRoomMutation(conversationId: string): void;
+    shouldSuppressRemoteRoomRefetch(conversationId: string): boolean;
+    publishConversationUpdate(conversation: AXConversation): void;
+    publishConversationCreated(conversation: AXConversation): void;
+    publishTypingIndicator(indicator: AXConversationTypingIndicator): void;
+    publishPresenceUpdate(update: AXConversationPresenceUpdate): void;
+    messagesForConversation(conversationId: string): Observable<AXConversationMessage>;
+    messageUpdatesForConversation(conversationId?: string): Observable<AXConversationMessage>;
+    typingIndicatorsForConversation(conversationId: string): Observable<AXConversationTypingIndicator>;
+    messageStatusChanges(conversationId?: string): Observable<{
+        messageId: string;
+        status: AXConversationMessage['status'];
+        timestamp: Date;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMConversationRealtimeBus, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMConversationRealtimeBus>;
+}
+
+interface AXMChatAssistCatalogPort {
+    loadCatalogTargets(force?: boolean): Promise<AXMChatAiTargetRow[]>;
+    getCachedAssist(assistId: string): AXPAiEffectiveAssistRowLite | null;
+    getAssist(assistId: string): Promise<AXPAiEffectiveAssistRowLite | null>;
+    primeAssist(row: AXPAiEffectiveAssistRowLite): void;
+    toSnapshot(row: AXPAiEffectiveAssistRowLite): AXMAssistConversationSnapshotLite;
+}
+declare const AXM_CHAT_ASSIST_CATALOG_PORT: InjectionToken<AXMChatAssistCatalogPort>;
+
+/**
+ * Session fields on {@link AXConversationService} not yet on the public API.
+ * Centralize the cast here so feature code does not repeat it.
+ */
+interface AXMConversationServiceSessionAdapter {
+    readonly currentUser: Signal<AXConversationParticipant | null>;
+    setCurrentUser(participant: AXConversationParticipant | null): void;
+    closeActiveConversation(): void;
+    resetConversationsPagination(): void;
+    loadConversations(): Promise<void>;
+}
+declare function createConversationServiceSessionAdapter(service: AXConversationService): AXMConversationServiceSessionAdapter;
+
+/**
+ * Represents a single comment in a thread.
+ * It can have nested replies (children).
+ */
+interface AXMComment extends AXMConversationMessage {
+    /**
+     * Nested replies to this comment.
+     */
+    replies: AXMComment[];
+    /**
+     * The number of direct replies to this comment.
+     */
+    replyCount: number;
+    /**
+     * The depth of the comment in the thread hierarchy.
+     * Root comments have a depth of 0.
+     */
+    depth: number;
+}
+/**
+ * Represents a comment thread, which is essentially a room for comments.
+ * It contains the total number of comments and the top-level comments.
+ */
+interface AXMCommentThread extends AXMConversationRoom {
+    /**
+     * The total number of comments in the thread.
+     */
+    commentCount: number;
+    /**
+     * An array of root-level comments.
+     */
+    comments: AXMComment[];
+}
+type AXMCommentEventType = 'add' | 'remove' | 'update';
+type AXMThreadEventType = 'add' | 'remove' | 'update';
+interface AXMCommentEvent {
+    type: AXMCommentEventType;
+    /**
+     * - For 'add' and 'update', payload is AXMComment.
+     * - For 'remove', payload is the comment ID (string).
+     */
+    payload: AXMComment | string;
+}
+interface AXMThreadEvent {
+    type: AXMThreadEventType;
+    /**
+     * - For 'add' and 'update', payload is AXMCommentThread.
+     * - For 'remove', payload is the thread ID (string).
+     */
+    payload: AXMCommentThread | string;
+}
+
+declare class AXMCommentManagementService {
+    private readonly entityService;
+    private readonly commentImplService;
+    private readonly sessionService;
+    private readonly usersService;
+    private readonly realtimeService;
+    private getCurrentUser;
+    private getUserInfo;
+    private formatComment;
+    private buildCommentTree;
+    private formatThread;
+    createThread(entityRef: AXMCommentEntityData, topic: string, title?: string): Promise<AXMCommentThread>;
+    getThread(entityRef: AXMCommentEntityData, topic: string): Promise<AXMCommentThread | null>;
+    listThreads(entityRef: AXMCommentEntityData, topic: string): Promise<AXMCommentThread[]>;
+    updateThread(entityRef: AXMCommentEntityData, topic: string, data: Partial<{
+        title: string;
+    }>): Promise<AXMCommentThread>;
+    deleteThread(entityRef: AXMCommentEntityData, topic: string): Promise<boolean>;
+    addComment(threadId: string, content: string, parentCommentId?: string, contentType?: string, userId?: string): Promise<AXMComment>;
+    getComments(threadId: string, nested: boolean): Promise<AXMComment[]>;
+    getComment(commentId: string): Promise<AXMComment>;
+    editComment(commentId: string, content: string, contentType?: string): Promise<AXMComment>;
+    deleteComment(commentId: string): Promise<boolean>;
+    addReaction(commentId: string, emoji: string): Promise<AXMComment>;
+    removeReaction(commentId: string, emoji: string): Promise<AXMComment>;
+    getReactions(commentId: string): Promise<AXReaction[]>;
+    likeComment(commentId: string): Promise<AXMComment>;
+    unlikeComment(commentId: string): Promise<AXMComment>;
+    pinComment(commentId: string): Promise<AXMComment>;
+    unpinComment(commentId: string): Promise<AXMComment>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMCommentManagementService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMCommentManagementService>;
+}
+
+declare abstract class AXMCommentRealtimeService {
+    abstract readonly comment$: Observable<AXMCommentEvent>;
+    abstract readonly thread$: Observable<AXMThreadEvent>;
+    abstract notifyComment(event: AXMCommentEvent): void;
+    abstract notifyThread(event: AXMThreadEvent): void;
+}
+declare class AXMCommentRealtimeServiceImpl extends AXMCommentRealtimeService {
+    private readonly _comment$;
+    readonly comment$: Observable<AXMCommentEvent>;
+    private readonly _thread$;
+    readonly thread$: Observable<AXMThreadEvent>;
+    notifyComment(event: AXMCommentEvent): void;
+    notifyThread(event: AXMThreadEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMCommentRealtimeServiceImpl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMCommentRealtimeServiceImpl>;
+}
+
+declare class AXMCommentComponent implements OnInit {
+    refrenceType: _angular_core.InputSignal<string>;
+    refrenceId: _angular_core.InputSignal<string>;
+    subject: _angular_core.InputSignal<string>;
+    moduleName: _angular_core.WritableSignal<string | undefined>;
+    entityName: _angular_core.WritableSignal<string | undefined>;
+    protected hasCooldown: _angular_core.WritableSignal<boolean>;
+    protected commentContent: _angular_core.WritableSignal<string>;
+    protected isSubmitting: _angular_core.WritableSignal<boolean>;
+    protected isReplyingMode: _angular_core.WritableSignal<boolean>;
+    protected isEditingMode: _angular_core.WritableSignal<boolean>;
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    protected activeReplyComment: _angular_core.WritableSignal<(AXMComment & {
+        userName: string;
+    }) | undefined>;
+    protected activeEditComment: _angular_core.WritableSignal<(AXMComment & {
+        userName: string;
+    }) | undefined>;
+    protected highlightedCommentId: _angular_core.WritableSignal<string | null>;
+    protected expandedCommentIds: _angular_core.WritableSignal<Set<string>>;
+    protected comments: _angular_core.WritableSignal<AXMComment[]>;
+    protected thread: _angular_core.WritableSignal<AXMCommentThread | undefined>;
+    protected wysiwygOptions: _angular_core.WritableSignal<{
+        look: AXStyleLookType;
+    }>;
+    protected wysiwygEditor: _angular_core.Signal<AXWysiwygContainerComponent>;
+    private readonly commentService;
+    private readonly realtimeService;
+    private readonly sessionService;
+    private readonly toastService;
+    private readonly dialogService;
+    private readonly inAppNotificationService;
+    private readonly router;
+    private readonly activatedRoute;
+    private readonly sanitizer;
+    private readonly translationService;
+    private readonly destroyRef;
+    private readonly elementRef;
+    ngOnInit(): void;
+    loadComments(): Promise<void>;
+    /** Opens edit mode for the target comment (or its reply). */
+    protected editMessage(comment: AXMComment, reply?: AXMComment, userName?: string): void;
+    /** Opens reply mode, optionally mentioning a specific reply author. */
+    protected replyMessage(comment: AXMComment, reply?: AXMComment, userName?: string): void;
+    protected deleteComment(commentId: string): Promise<void>;
+    protected resetReplyEditState(): void;
+    protected submitComment(): Promise<void>;
+    protected toggleLike(comment: AXMComment): Promise<void>;
+    protected isLikedByUser(comment: AXMComment): boolean;
+    protected getReactionsCount(comment: AXMComment): number;
+    protected isRepliesExpanded(commentId: string): boolean;
+    protected onRepliesExpandedChange(commentId: string, expanded: boolean): void;
+    private expandReplies;
+    /**
+     * Scrolls to the referenced comment and triggers a highlight pulse animation.
+     * Expands parent replies if needed to ensure the target is in the DOM.
+     */
+    protected scrollMain(): void;
+    /**
+     * Scrolls to a comment element and applies a highlight pulse animation.
+     * Uses setTimeout to wait for Angular to render after signal updates.
+     */
+    private scrollToAndHighlight;
+    protected sanitizeHtml(htmlContent: string | undefined): _angular_platform_browser.SafeHtml;
+    private handleAddComment;
+    private handleUpdateComment;
+    private getCurrentUser;
+    private updateLikeStatus;
+    private removeMessageById;
+    /** Workaround: Quill editor may not sync immediately with ngModel on clear */
+    private clearEditorContent;
+    /** Workaround: Quill editor may not sync immediately with ngModel on set */
+    private setEditorContent;
+    /** Shorthand translator scoped to the comments feature */
+    private t;
+    private showToast;
+    private showTranslatedToast;
+    protected getCommentText(comment: AXMComment): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMCommentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMCommentComponent, "axm-comment", never, { "refrenceType": { "alias": "refrenceType"; "required": true; "isSignal": true; }; "refrenceId": { "alias": "refrenceId"; "required": true; "isSignal": true; }; "subject": { "alias": "subject"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Extracts display text from a message payload (text messages and captions).
+ */
+declare function axmExtractTextFromPayload(payload: AXMessagePayload | undefined): string;
+
+declare abstract class AXMCommentService {
+    abstract createThread(entityRef: AXMCommentEntityData, topic: string, title?: string): Promise<AXMCommentThread>;
+    abstract getThread(entityRef: AXMCommentEntityData, topic: string): Promise<AXMCommentThread | null>;
+    abstract listThreads(entityRef: AXMCommentEntityData, topic: string): Promise<AXMCommentThread[]>;
+    abstract updateThread(entityRef: AXMCommentEntityData, topic: string, data: Partial<{
+        title: string;
+    }>): Promise<AXMCommentThread>;
+    abstract deleteThread(entityRef: AXMCommentEntityData, topic: string): Promise<boolean>;
+    abstract addComment(threadId: string, content: string, parentCommentId?: string, contentType?: string, userId?: string): Promise<AXMComment>;
+    abstract getComments(threadId: string, nested: boolean): Promise<AXMComment[]>;
+    abstract getComment(commentId: string): Promise<AXMComment>;
+    abstract editComment(commentId: string, content: string, contentType?: string): Promise<AXMComment>;
+    abstract deleteComment(commentId: string): Promise<boolean>;
+    abstract addReaction(commentId: string, emoji: string): Promise<AXMComment>;
+    abstract removeReaction(commentId: string, emoji: string): Promise<AXMComment>;
+    abstract getReactions(commentId: string): Promise<AXReaction[]>;
+    abstract likeComment(commentId: string): Promise<AXMComment>;
+    abstract unlikeComment(commentId: string): Promise<AXMComment>;
+    abstract pinComment(commentId: string): Promise<AXMComment>;
+    abstract unpinComment(commentId: string): Promise<AXMComment>;
+}
+declare class AXMCommentServiceImpl {
+    private readonly entityService;
+    private readonly roomService;
+    private readonly messageService;
+    private readonly filterService;
+    private readonly translationService;
+    createThread(creatorUser: AXPUserReference, entityRef: AXMCommentEntityData, topic: string, title?: string): Promise<AXMConversationRoom>;
+    getThread(entityRef: AXMCommentEntityData, topic: string): Promise<AXMConversationRoom | null>;
+    listThreads(entityRef: AXMCommentEntityData, topic: string): Promise<AXMConversationRoom[]>;
+    updateThread(threadId: string, data: Partial<{
+        title: string;
+    }>): Promise<AXMConversationRoom>;
+    deleteThread(threadId: string): Promise<boolean>;
+    addComment(threadId: string, content: string, author: AXPUserReference, parentCommentId?: string, _contentType?: string): Promise<AXMConversationMessage>;
+    getComments(threadId: string): Promise<AXMConversationMessage[]>;
+    getComment(commentId: string): Promise<AXMConversationMessage>;
+    editComment(commentId: string, content: string, _editor: AXPUserReference, _contentType?: string): Promise<AXMConversationMessage>;
+    deleteComment(commentId: string): Promise<boolean>;
+    updateReactions(commentId: string, reactions: AXReaction[]): Promise<AXMConversationMessage>;
+    getReactions(commentId: string): Promise<AXReaction[]>;
+    pinComment(commentId: string, pinned: boolean): Promise<AXMConversationMessage>;
+    private requireRoom;
+    private requireMessage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMCommentServiceImpl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMCommentServiceImpl>;
+}
+
+/** How to show comments in entity single view: as a section (default) or as a separate page. */
+type CommentsDisplayMode = 'section' | 'page';
+/** Component key used when display is 'page'. Register a page component with this key via AXP_PAGE_COMPONENT_PROVIDER. */
+declare const COMMENTS_PAGE_COMPONENT_KEY = "entity-comments-page";
+type CommentsPluginOptions = {
+    /** Where to show comments: section (inline) or page (separate tab). Default 'section' */
+    display?: CommentsDisplayMode;
+    /** Icon for the comments page (when display is 'page'). Default 'fa-light fa-comments' */
+    icon?: string;
+    /** Title override for comments section/page. Default '@conversation:terms.common.comments' */
+    title?: string;
+};
+/**
+ * Comments plugin.
+ * - When display is 'section' (default), adds a section to the single layout with the comment widget.
+ * - When display is 'page', adds a page to entity.pages with COMMENTS_PAGE_COMPONENT_KEY.
+ * - Always adds a list action to open the comment popup.
+ */
+declare const commentsPlugin: AXPEntityActionPlugin;
+
+interface AXMAddReactionCommandInput {
+    commentId: string;
+    reaction: AXMReactionType;
+}
+declare class AXMAddReactionCommand implements AXPCommand<AXMAddReactionCommandInput, void> {
+    execute(input: AXMAddReactionCommandInput): AXPCommandExecuteResultPromise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAddReactionCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMAddReactionCommand>;
+}
+
+interface AXMShowCommentPopupCommandInput {
+    data?: Record<string, unknown>;
+    options?: {
+        refType?: string;
+        refId?: string;
+        subject?: string;
+    };
+}
+/**
+ * Opens the comments popup for a referenced entity record.
+ * Replaces the former `show-comment-popup` workflow (single popup step).
+ */
+declare class AXMShowCommentPopupCommand implements AXPCommand<AXMShowCommentPopupCommandInput> {
+    private readonly popupService;
+    private readonly translate;
+    execute(input?: AXMShowCommentPopupCommandInput): AXPCommandExecuteResultPromise;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMShowCommentPopupCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMShowCommentPopupCommand>;
+}
+
+/**
+ * Build-time only. Do not import from Angular modules.
+ */
+declare const axmShowCommentPopupCommandDefinition: {
+    key: string;
+    title: string;
+    description: string;
+    executionMode: "frontend";
+    inputs: {
+        name: string;
+        title: string;
+        description: string;
+        interface: {
+            name: string;
+        };
+    }[];
+    outcomes: {
+        mode: "static";
+        values: string[];
+    };
+    ai: {
+        tags: string[];
+    };
+    categories: _acorex_platform_framework_shared_core.AXPDefinitionCategory[];
+};
+
+declare class AXMCommentPopupComponent extends AXBasePageComponent {
+    refrenceType: _angular_core.InputSignal<string>;
+    refrenceId: _angular_core.InputSignal<string>;
+    subject: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMCommentPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMCommentPopupComponent, "axm-comment-popup", never, { "refrenceType": { "alias": "refrenceType"; "required": true; "isSignal": true; }; "refrenceId": { "alias": "refrenceId"; "required": true; "isSignal": true; }; "subject": { "alias": "subject"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXMCommentWidgetViewComponent extends AXPValueWidgetComponent<AXPEntityReference & {
+    subject: string;
+}> {
+    protected refrenceType: _angular_core.Signal<any>;
+    protected refrenceId: _angular_core.Signal<any>;
+    protected subject: _angular_core.Signal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMCommentWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMCommentWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPCommentWidget: AXPWidgetConfig;
+
+/** Entity reference an entity-scoped chat is bound to (stored in conversation metadata). */
+interface AXMEntityChatRef {
+    entityId: string;
+    entityType: string;
+}
+/**
+ * Conversation metadata for an entity-scoped assist chat.
+ * Keeps `assistId` so the existing assist reply pipeline still answers in entity chats.
+ */
+declare function axmBuildEntityChatConversationMetadata(args: {
+    entityId: string;
+    entityType: string;
+    assistId: string;
+}): Record<string, unknown>;
+/**
+ * Resolves the entity reference from conversation metadata.
+ * `AXConversationService.createConversation` may nest the UI object, so values
+ * are also probed at `metadata.metadata.*`.
+ */
+declare function axmExtractEntityRefFromMetadata(metadata: Record<string, unknown> | undefined): AXMEntityChatRef | undefined;
+/** True when the conversation is bound to an entity (has both entity id and type). */
+declare function axmConversationIsEntityChat(metadata: Record<string, unknown> | undefined): boolean;
+/** True when conversation metadata targets the given entity reference. */
+declare function axmConversationMatchesEntity(metadata: Record<string, unknown> | undefined, ref: AXMEntityChatRef): boolean;
+
+/** Arguments accepted by `AXConversationService.createConversation`, prebuilt for an entity chat. */
+interface AXMEntityChatCreateData {
+    participantIds: string[];
+    type: 'bot';
+    options: {
+        title: string;
+        avatar?: string;
+        icon: string;
+        metadata: Record<string, unknown>;
+    };
+}
+/**
+ * Backing service for the entity-scoped mini chat: finds the conversations bound to an entity
+ * (an entity may have several) and prepares the create payload for a new entity assist chat.
+ *
+ * Conversation creation/selection is performed by the caller using its own
+ * {@link AXConversationService} instance so the mini chat keeps its active-selection state
+ * isolated from the main chat page.
+ */
+declare class AXMEntityChatService {
+    private readonly injector;
+    private readonly conversationService;
+    private readonly entityRegistry;
+    private readonly translationService;
+    private readonly defaultAssistResolver;
+    /**
+     * Resolved lazily: this service is `providedIn: 'root'` but depends on module-scoped chat APIs
+     * and optional AI services that must not be requested during the same hydration pass as chat UI.
+     */
+    private get conversationApi();
+    /** Returns every conversation bound to the given entity reference. */
+    findEntityConversations(ref: AXMEntityChatRef): Promise<AXConversation[]>;
+    /** Creates a new entity-scoped assist conversation and selects it as the active conversation. */
+    createEntityChat(ref: AXMEntityChatRef, assistId?: string): Promise<AXConversation>;
+    /**
+     * Builds the `createConversation` payload for a new entity assist chat.
+     * Uses `assistId` when provided, otherwise the tenant default assist.
+     */
+    buildEntityChatCreateData(ref: AXMEntityChatRef, assistId?: string): Promise<AXMEntityChatCreateData>;
+    /** Resolves the assist catalog row to chat with (explicit id → tenant default → first row). */
+    private resolveAssistRow;
+    private resolveDefaultAssistId;
+    private resolveTitle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMEntityChatService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMEntityChatService>;
+}
+
+/**
+ * Compact scrollable list of inbox AI-assist chats (non-entity bot / assist conversations).
+ */
+declare class AXMMiniChatInboxHistoryComponent implements OnInit {
+    private readonly conversationApi;
+    private readonly conversationFilter;
+    /** Emits when the user picks a conversation from the list. */
+    readonly conversationSelected: _angular_core.OutputEmitterRef<string>;
+    /** Emits when the user starts a new chat from the empty state. */
+    readonly newChatRequested: _angular_core.OutputEmitterRef<void>;
+    /** Emits whether the loaded history contains at least one conversation. */
+    readonly hasConversationsChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly conversations: _angular_core.WritableSignal<AXConversation[]>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    /** Reloads AI-assist inbox conversations. */
+    refresh(): Promise<void>;
+    protected resolveListAvatar(conversation: AXConversation): {
+        title: string;
+        avatar?: string;
+        icon?: string;
+    };
+    protected onSelect(conversationId: string): void;
+    protected onNewChat(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatInboxHistoryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMiniChatInboxHistoryComponent, "axm-mini-chat-inbox-history", never, {}, { "conversationSelected": "conversationSelected"; "newChatRequested": "newChatRequested"; "hasConversationsChange": "hasConversationsChange"; }, never, never, true, never>;
+}
+
+type AXMMiniChatInboxConversationFilter = (conversation: AXConversation) => boolean;
+declare const AXM_MINI_CHAT_INBOX_CONVERSATION_FILTER: InjectionToken<AXMMiniChatInboxConversationFilter>;
+
+/** Anchor element for overlay positioning. */
+type AXMMiniChatPanelAnchor = Element | ElementRef<HTMLElement>;
+/**
+ * Common placement aliases mapped to {@link AXPlacement}.
+ * Examples: `top-right` → `top-end`, `bottom-left` → `bottom-start`.
+ */
+type AXMMiniChatPanelSide = AXPlacement | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'left' | 'right';
+/** Fixed viewport coordinates (px). Ignored when `anchor` is set. */
+interface AXMMiniChatPanelPosition {
+    x: number;
+    y: number;
+}
+/** Mini chat panel scope: entity-bound threads or main inbox (non-entity chats). */
+type AXMMiniChatPanelScope = 'entity' | 'inbox';
+/** Session key used for the global inbox mini chat (non-entity conversations). */
+declare const AXM_MINI_CHAT_INBOX_SESSION_KEY = "__inbox__";
+/** Persisted panel state for a mini chat session. */
+interface AXMMiniChatPanelSessionState {
+    view: 'thread' | 'history';
+    selectedChatId?: string;
+    hasOpened: boolean;
+}
+/** Options passed to {@link AXMMiniChatPanelService.open}. */
+interface AXMMiniChatPanelOpenOptions {
+    /** Default: `entity`. Use `inbox` for regular (non-entity) chats shown in the main chat sidebar. */
+    scope?: AXMMiniChatPanelScope;
+    entityId?: string;
+    entityType?: string;
+    assistId?: string;
+    title?: string;
+    showInfoBar?: boolean;
+    showComposer?: boolean;
+    /** Fixed viewport position (px). Ignored when `anchor` is set. */
+    position?: AXMMiniChatPanelPosition;
+    /** Anchor element for popover placement. */
+    anchor?: AXMMiniChatPanelAnchor;
+    /** Placement relative to anchor. Default: `top-end` when anchored. */
+    placement?: AXMMiniChatPanelSide;
+    offsetX?: number;
+    offsetY?: number;
+    autoFlip?: boolean;
+    /** When true, always opens a fresh conversation thread. */
+    forceNewChat?: boolean;
+}
+
+/**
+ * Host for inbox mini chat with an isolated {@link AXConversationService} so the header
+ * slot does not change the main chat page selection while the user is on the chat route.
+ */
+declare class AXMMiniChatInboxPanelHostComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly showInfoBar: _angular_core.InputSignal<boolean>;
+    readonly showComposer: _angular_core.InputSignal<boolean>;
+    readonly requestClose: _angular_core.InputSignal<() => void>;
+    readonly initialView: _angular_core.InputSignal<"thread" | "history">;
+    readonly initialConversationId: _angular_core.InputSignal<string | undefined>;
+    readonly startWithNewChat: _angular_core.InputSignal<boolean>;
+    readonly onSessionChange: _angular_core.InputSignal<((state: Pick<AXMMiniChatPanelSessionState, "view" | "selectedChatId">) => void) | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatInboxPanelHostComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMiniChatInboxPanelHostComponent, "axm-mini-chat-inbox-panel-host", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "showInfoBar": { "alias": "showInfoBar"; "required": false; "isSignal": true; }; "showComposer": { "alias": "showComposer"; "required": false; "isSignal": true; }; "requestClose": { "alias": "requestClose"; "required": true; "isSignal": true; }; "initialView": { "alias": "initialView"; "required": false; "isSignal": true; }; "initialConversationId": { "alias": "initialConversationId"; "required": false; "isSignal": true; }; "startWithNewChat": { "alias": "startWithNewChat"; "required": false; "isSignal": true; }; "onSessionChange": { "alias": "onSessionChange"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Root header slot that toggles the inbox mini chat overlay (AI-assist conversations only).
+ */
+declare class AXMMiniChatHeaderSlotComponent {
+    private readonly panelService;
+    private readonly chatButtonRef;
+    protected onToggleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatHeaderSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMiniChatHeaderSlotComponent, "axm-mini-chat-header-slot", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Scrollable list of entity-scoped conversations for the mini chat panel.
+ * Loads chats via {@link AXMEntityChatService.findEntityConversations}.
+ */
+declare class AXMMiniChatHistoryComponent implements OnInit {
+    private readonly entityChatService;
+    readonly entityId: _angular_core.InputSignal<string>;
+    readonly entityType: _angular_core.InputSignal<string>;
+    /** Emits when the user picks a conversation from the list. */
+    readonly conversationSelected: _angular_core.OutputEmitterRef<string>;
+    /** Emits when the user starts a new chat from the empty state. */
+    readonly newChatRequested: _angular_core.OutputEmitterRef<void>;
+    /** Emits whether the loaded history contains at least one conversation. */
+    readonly hasConversationsChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly conversations: _angular_core.WritableSignal<AXConversation[]>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    /** Reloads the entity conversation list (call when the history panel becomes visible). */
+    refresh(): Promise<void>;
+    protected resolveListAvatar(conversation: AXConversation): {
+        title: string;
+        avatar?: string;
+        icon?: string;
+    };
+    protected onSelect(conversationId: string): void;
+    protected onNewChat(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatHistoryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMiniChatHistoryComponent, "axm-mini-chat-history", never, { "entityId": { "alias": "entityId"; "required": true; "isSignal": true; }; "entityType": { "alias": "entityType"; "required": true; "isSignal": true; }; }, { "conversationSelected": "conversationSelected"; "newChatRequested": "newChatRequested"; "hasConversationsChange": "hasConversationsChange"; }, never, never, true, never>;
+}
+
+/**
+ * Opens the entity mini chat panel via {@link AXOverlayService}.
+ * Restores the last conversation per entity on reopen; use {@link forceNewChat} for an explicit new thread.
+ */
+declare class AXMMiniChatPanelService {
+    private readonly overlayService;
+    private readonly conversationService;
+    private readonly conversationApi;
+    private readonly document;
+    private readonly router;
+    private overlayRef;
+    private anchorElement;
+    private keydownHandler;
+    private outsideClickHandler;
+    private routerSubscription;
+    /** Active conversation before the panel took over selection (restored on close). */
+    private savedActiveConversationId;
+    /** Per-entity session (view, selected conversation) restored when the panel reopens. */
+    private readonly sessions;
+    /** Reactive open state for launcher UI (FAB icon). */
+    readonly panelOpen: _angular_core.WritableSignal<boolean>;
+    /** True while the mini chat overlay is mounted. */
+    isOpen(): boolean;
+    /** Closes the overlay when it is open. */
+    close(): void;
+    /** Toggles the inbox mini chat overlay (regular non-entity conversations). */
+    toggleInbox(options?: Omit<AXMMiniChatPanelOpenOptions, 'scope' | 'entityId' | 'entityType'>): void;
+    /** Toggles the overlay, restoring the last session when reopening. */
+    toggle(options: AXMMiniChatPanelOpenOptions): void;
+    /**
+     * Opens the mini chat panel overlay (replaces any existing overlay).
+     * Restores the last session for the entity unless {@link AXMMiniChatPanelOpenOptions.forceNewChat} is set.
+     */
+    open(options: AXMMiniChatPanelOpenOptions): Promise<void>;
+    private buildEntityKey;
+    private disposeOverlayOnly;
+    private handleOverlayDisposed;
+    private bindDismissHandlers;
+    /** Ignore clicks on the anchor, overlay panel, or nested dropdown menus. */
+    private isInsideInteractiveSurface;
+    private removeDismissHandlers;
+    private captureActiveConversation;
+    private restoreActiveConversation;
+    private resolveAnchorElement;
+    private normalizePlacement;
+    private applyFixedPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatPanelService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMMiniChatPanelService>;
+}
+
+/**
+ * Fixed bottom-right FAB that toggles the entity mini chat overlay via {@link AXMMiniChatPanelService}.
+ * Reopens the last conversation for the entity; pass {@link placement} to control popover side.
+ */
+declare class AXMMiniChatLauncherComponent {
+    protected readonly panelService: AXMMiniChatPanelService;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    readonly entityId: _angular_core.InputSignal<string>;
+    readonly entityType: _angular_core.InputSignal<string>;
+    readonly assistId: _angular_core.InputSignal<string | undefined>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Placement relative to the FAB when no custom {@link position} is set. Default: `top-end`. */
+    readonly placement: _angular_core.InputSignal<"bottom-start" | "bottom-end" | "top-start" | "top-end" | "top" | "bottom">;
+    readonly offsetX: _angular_core.InputSignal<number>;
+    readonly offsetY: _angular_core.InputSignal<number>;
+    private readonly fabRef;
+    protected onFabClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatLauncherComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMiniChatLauncherComponent, "axm-mini-chat-launcher", never, { "entityId": { "alias": "entityId"; "required": true; "isSignal": true; }; "entityType": { "alias": "entityType"; "required": true; "isSignal": true; }; "assistId": { "alias": "assistId"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "offsetX": { "alias": "offsetX"; "required": false; "isSignal": true; }; "offsetY": { "alias": "offsetY"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Mini chat panel overlay: header, thread view, and history (entity list or main inbox sidebar).
+ */
+declare class AXMMiniChatPanelComponent implements OnInit, OnDestroy {
+    private readonly conversationService;
+    private readonly conversationApi;
+    private readonly realtimeBus;
+    private readonly destroyRef;
+    readonly scope: _angular_core.InputSignal<AXMMiniChatPanelScope>;
+    readonly entityId: _angular_core.InputSignal<string | undefined>;
+    readonly entityType: _angular_core.InputSignal<string | undefined>;
+    readonly assistId: _angular_core.InputSignal<string | undefined>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly showInfoBar: _angular_core.InputSignal<boolean>;
+    readonly showComposer: _angular_core.InputSignal<boolean>;
+    readonly requestClose: _angular_core.InputSignal<() => void>;
+    readonly initialView: _angular_core.InputSignal<"thread" | "history">;
+    readonly initialConversationId: _angular_core.InputSignal<string | undefined>;
+    readonly startWithNewChat: _angular_core.InputSignal<boolean>;
+    readonly onSessionChange: _angular_core.InputSignal<((state: Pick<AXMMiniChatPanelSessionState, "view" | "selectedChatId">) => void) | undefined>;
+    protected readonly view: _angular_core.WritableSignal<"thread" | "history">;
+    protected readonly selectedChatId: _angular_core.WritableSignal<string | undefined>;
+    protected readonly historyHasItems: _angular_core.WritableSignal<boolean>;
+    protected readonly isInboxScope: _angular_core.Signal<boolean>;
+    /** Bumps when shared conversation storage changes so the header title stays in sync. */
+    private readonly storageRevision;
+    /** Active conversation title for the thread header; null when none is selected yet. */
+    protected readonly headerTitle: _angular_core.Signal<string | null>;
+    private readonly cachedHeaderTitle;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected closePanel(): void;
+    protected openHistory(): void;
+    protected onHistoryHasConversationsChange(hasItems: boolean): void;
+    protected selectChat(conversationId: string): void;
+    protected onConversationOpened(conversationId: string): void;
+    protected startNewChat(): Promise<void>;
+    private syncSession;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMiniChatPanelComponent, "axm-mini-chat-panel", never, { "scope": { "alias": "scope"; "required": false; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": false; "isSignal": true; }; "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "assistId": { "alias": "assistId"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "showInfoBar": { "alias": "showInfoBar"; "required": false; "isSignal": true; }; "showComposer": { "alias": "showComposer"; "required": false; "isSignal": true; }; "requestClose": { "alias": "requestClose"; "required": true; "isSignal": true; }; "initialView": { "alias": "initialView"; "required": false; "isSignal": true; }; "initialConversationId": { "alias": "initialConversationId"; "required": false; "isSignal": true; }; "startWithNewChat": { "alias": "startWithNewChat"; "required": false; "isSignal": true; }; "onSessionChange": { "alias": "onSessionChange"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Compact, entity-scoped chat: renders a single conversation thread (message list) with an optional
+ * info-bar and composer. Opens an existing chat by {@link chatId}, or starts a new entity assist chat
+ * (created lazily on first send and tagged with `entityId` / `entityType` in conversation metadata).
+ *
+ * Uses the shared {@link AXConversationService} (same instance as the main chat page) so message
+ * streams, realtime updates, and assist replies behave identically. Selecting a chat / starting a
+ * new one is coordinated by the host through {@link chatId} and {@link AXConversationService}.
+ */
+declare class AXMMiniChatComponent {
+    #private;
+    private readonly conversationService;
+    private readonly conversationApi;
+    private readonly assistResponse;
+    private readonly destroyRef;
+    /** Existing conversation id to open. When omitted (and no conversation is active), the new-chat composer is shown. */
+    readonly chatId: _angular_core.InputSignal<string | undefined>;
+    /** Entity reference the chat is (or will be) bound to; omitted for inbox (regular) chats. */
+    readonly entityId: _angular_core.InputSignal<string | undefined>;
+    readonly entityType: _angular_core.InputSignal<string | undefined>;
+    /** Assist used as the bot peer when creating a new entity chat (falls back to the tenant default). */
+    readonly assistId: _angular_core.InputSignal<string | undefined>;
+    readonly showInfoBar: _angular_core.InputSignal<boolean>;
+    readonly showComposer: _angular_core.InputSignal<boolean>;
+    /** Emits the active conversation id when one is opened or newly created. */
+    readonly conversationOpened: _angular_core.OutputEmitterRef<string>;
+    readonly hasActiveConversation: _angular_core.Signal<boolean>;
+    constructor();
+    /** New-chat composer created and selected a conversation; surface it to the host. */
+    onConversationCreated(conversationId: string): void;
+    onComposerGenerationCancelled(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMiniChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMiniChatComponent, "axm-mini-chat", never, { "chatId": { "alias": "chatId"; "required": false; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": false; "isSignal": true; }; "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "assistId": { "alias": "assistId"; "required": false; "isSignal": true; }; "showInfoBar": { "alias": "showInfoBar"; "required": false; "isSignal": true; }; "showComposer": { "alias": "showComposer"; "required": false; "isSignal": true; }; }, { "conversationOpened": "conversationOpened"; }, never, never, true, never>;
+}
+
+/** Fired after a user message is persisted — triggers assist, auto-reply, and realtime side effects. */
+declare const CONVERSATION_AFTER_MESSAGE_SENT_COMMAND = "Conversation:AfterMessageSent";
+/** Re-runs AI generation for a failed/incomplete assist placeholder. */
+declare const CONVERSATION_RETRY_ASSIST_RESPONSE_COMMAND = "Conversation:RetryAssistResponse";
+/** Marks conversation messages read and syncs chat notifications. */
+declare const CONVERSATION_SYNC_READ_STATE_COMMAND = "Conversation:SyncReadState";
+/** Marks a conversation as having unread messages. */
+declare const CONVERSATION_MARK_CONVERSATION_UNREAD_COMMAND = "Conversation:MarkConversationUnread";
+/** Sends or clears a typing indicator for the current user. */
+declare const CONVERSATION_EMIT_TYPING_INDICATOR_COMMAND = "Conversation:EmitTypingIndicator";
+/** Starts a new bot conversation with the given AI assist model. */
+declare const CONVERSATION_START_ASSIST_CHAT_COMMAND = "Conversation:StartAssistChat";
+/** Sends a user text message in the active assist chat, or starts a chat when {@code assistId} is provided. */
+declare const CONVERSATION_SEND_ASSIST_CHAT_MESSAGE_COMMAND = "Conversation:SendAssistChatMessage";
+/** Starts or reuses a private chat with another user and navigates to the conversation. */
+declare const CONVERSATION_START_DIRECT_CHAT_COMMAND = "Conversation:StartDirectChat";
+/** Opens an existing conversation in the chat app. */
+declare const CONVERSATION_OPEN_CHAT_COMMAND = "Conversation:OpenChat";
+
+export { AXMAddReactionCommand, AXMAssistSuggestionChipsComponent, AXMChatComponent, AXMChatConversationApi, AXMChatEntityConversationApi, AXMChatEntityConversationFocusHandler, AXMChatEntityConversationRoomQueryService, AXMChatEntityMessageApi, AXMChatEntityRealtimeApi, AXMChatEntityUserApi, AXMChatMessageApi, AXMChatRealtimeApi, AXMChatUserApi, AXMCommentComponent, AXMCommentManagementService, AXMCommentPopupComponent, AXMCommentRealtimeService, AXMCommentRealtimeServiceImpl, AXMCommentService, AXMCommentServiceImpl, AXMCommentWidgetViewComponent, AXMConversationAssistBackgroundOperationHandler, AXMConversationEntityStoreService, AXMConversationFocusService, AXMConversationModule, AXMConversationRealtimeBus, AXMEntityChatService, AXMMiniChatComponent, AXMMiniChatHeaderSlotComponent, AXMMiniChatHistoryComponent, AXMMiniChatInboxHistoryComponent, AXMMiniChatInboxPanelHostComponent, AXMMiniChatLauncherComponent, AXMMiniChatPanelComponent, AXMMiniChatPanelService, AXMShowCommentPopupCommand, AXM_AI_MANAGEMENT_AGENT_ENTITY_NAME, AXM_AI_MANAGEMENT_ASSIST_ENTITY_NAME, AXM_AI_MANAGEMENT_MODULE_NAME, AXM_ASSIST_DEFAULT_RESOLVER_PORT, AXM_ASSIST_TRANSCRIPT_LINE_PAYLOAD_TYPE, AXM_CHAT_ASSIST_CATALOG_PORT, AXM_CHAT_EMPTY_STATE_COMPONENT, AXM_CHAT_SIDEBAR_ACTION_PROVIDER, AXM_CONVERSATION_ASSIST_BACKGROUND_OPERATION_HANDLERS, AXM_CONVERSATION_ASSIST_BACKGROUND_OPERATION_KEY, AXM_CONVERSATION_ASSIST_RESPONSE_PORT, AXM_CONVERSATION_CHAT_ATTACHMENT_CATEGORY, AXM_CONVERSATION_CHAT_ATTACHMENT_REF_TYPE, AXM_CONVERSATION_REGULAR_AUTO_REPLY_PORT, AXM_CONVERSATION_TAB_BOT, AXM_MINI_CHAT_INBOX_CONVERSATION_FILTER, AXM_MINI_CHAT_INBOX_SESSION_KEY, AXPCommentWidget, COMMENTS_PAGE_COMPONENT_KEY, CONVERSATION_AFTER_MESSAGE_SENT_COMMAND, CONVERSATION_EMIT_TYPING_INDICATOR_COMMAND, CONVERSATION_MARK_CONVERSATION_UNREAD_COMMAND, CONVERSATION_OPEN_CHAT_COMMAND, CONVERSATION_RETRY_ASSIST_RESPONSE_COMMAND, CONVERSATION_SEND_ASSIST_CHAT_MESSAGE_COMMAND, CONVERSATION_START_ASSIST_CHAT_COMMAND, CONVERSATION_START_DIRECT_CHAT_COMMAND, CONVERSATION_SYNC_READ_STATE_COMMAND, axmApplyAnswerTextToAssistPayloadLine, axmAssistFollowUpItemsFromUnknown, axmAssistHasFinalizeMetadata, axmAssistLastTranscriptLine, axmAssistNormalizeFollowUpItemForConversation, axmAssistNormalizeFollowUpItemsForConversation, axmAssistPersistedMessageLooksComplete, axmAssistResolveFollowUpCommandName, axmAssistStarterPromptChipItems, axmAssistUserFacingPayloadLine, axmAssistUserVisibleItemsForLine, axmAssistWidgetNodeDedupeKey, axmAssistWidgetNodeFromUnknown, axmBuildAiChatConversationMetadata, axmBuildAssistPeerParticipantFromCreateData, axmBuildAssistPeerParticipantFromId, axmBuildAssistTranscriptLinePayload, axmBuildAutoTitleFromUserText, axmBuildEntityChatConversationMetadata, axmChatAiPeerParticipantId, axmChatAiTargetAvatarUrl, axmChatAiTargetDisplayDescription, axmChatAiTargetDisplayName, axmChatAiTargetShortcutDescriptionKey, axmCoerceDate, axmCoerceTimestampMs, axmComputeConversationUnreadCount, axmConversationHasAiChat, axmConversationIsEntityChat, axmConversationMatchesEntity, axmExtractAssistIdFromMetadata, axmExtractAssistSnapshotFromMetadata, axmExtractDirectAgentIdFromMetadata, axmExtractEntityRefFromMetadata, axmExtractModelEntityIdFromMetadata, axmExtractTextFromPayload, axmFilterChatAiTargets, axmIsAssistBotConversation, axmIsAssistPeerParticipant, axmIsAssistRetryableStatus, axmIsAssistStreamingMessage, axmIsAssistStreamingStatus, axmIsAssistTerminalStatus, axmLoadChatAiTargets, axmMessageCountsTowardUnread, axmMessageEntityToMessage, axmNormalizeAssistTranscriptForChatUi, axmNormalizeAssistTranscriptLineResponses, axmParseAssistTranscriptLinePayload, axmParseAssistTranscriptTextEnvelope, axmPartitionAssistAnswerText, axmReadAssistAiTranscript, axmReadAssistAiTranscriptRaw, axmReadAssistResponseError, axmReadAssistResponseStatus, axmReadPlainTextMessagePayload, axmReadReplyToUserMessageId, axmResolveAssistFinalAnswerText, axmResolveChatAiTargetText, axmRoomEntityToConversation, axmRoomWithAssistPeerDisplayName, axmSanitizeAssistUserAnswerText, axmShouldPreferPersistedAssistOverLiveCache, axmShowCommentPopupCommandDefinition, axmSortMessagesNewestFirst, axmSyncAssistPeerDisplayName, axmSyntheticEmbedMessage, axmUserRowToParticipant, commentsPlugin, createConversationServiceSessionAdapter, persistChatAttachment };
+export type { AXMAddReactionCommandInput, AXMAssistConversationSnapshotLite, AXMAssistDefaultResolverPort, AXMAssistStarterPromptChipOptions, AXMChatAiTargetRow, AXMChatAssistCatalogPort, AXMChatSidebarAction, AXMComment, AXMCommentEvent, AXMCommentEventType, AXMCommentThread, AXMConversationAssistResponsePort, AXMConversationRegularAutoReplyPort, AXMConversationServiceSessionAdapter, AXMEntityChatCreateData, AXMEntityChatRef, AXMMiniChatInboxConversationFilter, AXMMiniChatPanelAnchor, AXMMiniChatPanelOpenOptions, AXMMiniChatPanelPosition, AXMMiniChatPanelScope, AXMMiniChatPanelSessionState, AXMMiniChatPanelSide, AXMSendAssistChatMessageOptions, AXMShowCommentPopupCommandInput, AXMThreadEvent, AXMThreadEventType, AXPAiChatFollowUpCommandLite, AXPAiChatFollowUpItemLite, AXPAiChatMessageLite, AXPAiChatNodeOrFollowUpResponseLite, AXPAiChatTextResponseLite, AXPAiEffectiveAssistRowLite, AxmAssistPartitionedAnswerText, AxmAssistResponseStatus, AxmAssistTranscriptLinePayload, AxmAssistUserVisibleItem, CommentsDisplayMode, CommentsPluginOptions };