import * as i0 from '@angular/core';
import { Injector, OnInit } from '@angular/core';
import * as i1 from '@acorex/platform/layout/widget-core';
import { AXPValueWidgetComponent, AXPWidgetConfig } from '@acorex/platform/layout/widget-core';
import * as i2 from '@acorex/platform/workflow';
import { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflow } from '@acorex/platform/workflow';
import * as i6 from '@angular/router';
import { AXPEntity } from '@acorex/platform/common';
import { AXPEntityModel, AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
import { AXPContent, AXPUserReference, AXPFileListItem, AXPContentType, AXPDeviceService, AXPEntityReference } from '@acorex/platform/core';
import { Observable } from 'rxjs';
import { AXPPageLayoutBaseComponent } from '@acorex/platform/layout/views';
import * as _angular_platform_browser from '@angular/platform-browser';
import { DomSanitizer } from '@angular/platform-browser';
import { AXWysiwygContainerComponent } from '@acorex/components/wysiwyg';
import { AXStyleLookType } from '@acorex/cdk/common';
import { AXBasePageComponent } from '@acorex/components/page';

declare const RootConfig: {
    config: {
        i18n: string;
        module: string;
        route: string;
    };
    module: {
        route: string;
        name: string;
        title: string;
        icon: string;
    };
    entities: {
        room: {
            name: string;
            title: string;
            source: string;
            icon: string;
        };
        message: {
            name: string;
            title: string;
            source: string;
            icon: string;
        };
        tab: {
            name: string;
            title: string;
            source: string;
            icon: string;
        };
    };
};

declare class AXMConversationTabEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMConversationTabEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMConversationTabEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMConversationTabEntityModule>;
}

declare class AXMRoomEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMRoomEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMRoomEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMRoomEntityModule>;
}

declare class AXMMessageEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMMessageEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMMessageEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMMessageEntityModule>;
}

declare class AXMConversationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMConversationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMConversationModule, never, [typeof i1.AXPWidgetCoreModule, typeof i2.AXPWorkflowModule, typeof AXMConversationTabEntityModule, typeof AXMRoomEntityModule, typeof AXMMessageEntityModule], [typeof i6.RouterModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMConversationModule>;
}

declare function tabFactory(injector: Injector): Promise<AXPEntity | null>;

declare function roomFactory(injector: Injector): Promise<AXPEntity | null>;

type AXMSeenType = 'delivered' | 'read';
type AXMReactionType = 'like' | 'love' | 'laugh' | 'angry' | 'sad' | string;
interface AXMConversationReaction {
    author: AXPUserReference;
    type: AXMReactionType;
}
interface AXMConversationSeen {
    author: AXPUserReference;
    type: AXMSeenType;
}
interface AXMConversationMessage extends AXPEntityModel<string> {
    roomId: string;
    message: AXPContent;
    author: AXPUserReference;
    replyId?: string | null;
    reactions: AXMConversationReaction[];
    seen: AXMConversationSeen[];
    isPinned?: boolean;
}

/**
 * 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;
}
interface AXMCommentEntityData {
    entityId: string;
    entityTypeId: string;
    moduleName?: string;
    entityName?: string;
}

interface AXMConversationRoom extends AXPEntityModel<string> {
    title?: string;
    members: AXPUserReference[];
    entityRef?: AXMCommentEntityData;
    topic?: 'support' | 'group' | 'channel' | 'personal' | string;
    type?: 'chat' | 'comment';
    avatar?: AXPFileListItem | string | null;
}

declare abstract class AXMRoomService extends AXMEntityCrudServiceImpl<string, AXMConversationRoom> {
}
declare class AXMRoomServiceImpl extends AXMRoomService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMRoomServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMRoomServiceImpl>;
}

interface AXMConversationTab {
    id: string;
    name: string;
    title: string;
    color?: string;
    excludeRooms: AXMConversationRoom[];
    includeRooms: AXMConversationRoom[];
}

declare abstract class AXMConversationTabService extends AXMEntityCrudServiceImpl<string, AXMConversationTab> {
}
declare class AXMConversationTabServiceImpl extends AXMConversationTabService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMConversationTabServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMConversationTabServiceImpl>;
}

declare function messageFactory(injector: Injector): Promise<AXPEntity | null>;

declare abstract class AXMMessageService extends AXMEntityCrudServiceImpl<string, AXMConversationMessage> {
}
declare class AXMMessageServiceImpl extends AXMMessageService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMMessageServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMMessageServiceImpl>;
}

/**
 * Extended message interface for chat messages with UI-specific properties
 */
interface AXMChatMessage extends AXMConversationMessage {
}
/**
 * Extended room interface for chat rooms with UI-specific properties
 */
interface AXMChatRoom extends AXMConversationRoom {
    lastMessage?: AXMChatMessage;
    unreadCount: number;
}
type AXMChatRoomEvent = {
    type: 'add' | 'update';
    payload: AXMChatRoom;
} | {
    type: 'remove' | 'seen';
    payload: string;
};
type AXMChatMessageEvent = {
    type: 'add' | 'update';
    payload: AXMChatMessage;
} | {
    type: 'remove';
    payload: string;
};
type AXMChatTabEvent = {
    type: 'add' | 'update';
    payload: AXMConversationTab;
} | {
    type: 'remove';
    payload: string;
};

declare class AXMChatManagementService {
    private readonly chatService;
    private readonly sessionService;
    private readonly usersService;
    private readonly realtimeService;
    private readonly notificationConnectorService;
    private readonly userCache;
    private readonly messagePageSize;
    private getCurrentUser;
    private getUserInfo;
    private formatMessage;
    private formatRoom;
    private mapWithConcurrency;
    createRoom(memberIds: string[], title?: string, avatar?: string | null): Promise<AXMChatRoom>;
    getRoom(roomId: string): Promise<AXMChatRoom>;
    listRooms(skip?: number, take?: number): Promise<{
        items: AXMChatRoom[];
        total: number;
    }>;
    updateRoom(roomId: string, data: Partial<AXMConversationRoom>): Promise<AXMConversationRoom>;
    deleteRoom(roomId: string): Promise<boolean>;
    addParticipant(roomId: string, userId: string): Promise<AXMConversationRoom>;
    removeParticipant(roomId: string, userId: string): Promise<AXMConversationRoom>;
    createTab(data: Omit<AXMConversationTab, 'id'>): Promise<AXMConversationTab>;
    getTab(tabId: string): Promise<AXMConversationTab>;
    listTabs(skip?: number, take?: number): Promise<{
        items: AXMConversationTab[];
        total: number;
    }>;
    updateTab(tabId: string, data: Partial<AXMConversationTab>): Promise<AXMConversationTab>;
    deleteTab(tabId: string): Promise<boolean>;
    addIncludeRoomToTab(tabId: string, roomId: string): Promise<AXMConversationTab>;
    removeIncludeRoomFromTab(tabId: string, roomId: string): Promise<AXMConversationTab>;
    addExcludeRoomToTab(tabId: string, roomId: string): Promise<AXMConversationTab>;
    removeExcludeRoomFromTab(tabId: string, roomId: string): Promise<AXMConversationTab>;
    sendMessage(roomId: string, content: string, contentType?: AXPContentType, replyId?: string, userId?: string): Promise<AXMChatMessage>;
    getMessages(roomId: string, skip?: number, take?: number): Promise<{
        items: AXMChatMessage[];
        total: number;
    }>;
    getMessage(messageId: string): Promise<AXMChatMessage>;
    editMessage(messageId: string, content: string, contentType?: AXPContentType): Promise<AXMConversationMessage>;
    deleteMessage(messageId: string): Promise<boolean>;
    replyMessage(replyToMessageId: string, content: string, contentType?: AXPContentType): Promise<AXMConversationMessage>;
    pinMessage(messageId: string): Promise<AXMConversationMessage>;
    unpinMessage(messageId: string): Promise<AXMConversationMessage>;
    addReaction(messageId: string, type: AXMReactionType): Promise<AXMConversationMessage>;
    removeReaction(messageId: string, type: AXMReactionType): Promise<AXMConversationMessage>;
    getReactions(messageId: string): Promise<AXMConversationReaction[]>;
    markSeen(messageId: string, notify?: boolean): Promise<AXMConversationMessage>;
    getSeenBy(messageId: string): Promise<AXMConversationSeen[]>;
    markRoomSeen(roomId: string): Promise<boolean>;
    startTyping(roomId: string, userId?: string): Promise<void>;
    stopTyping(roomId: string, userId?: string): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMChatManagementService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMChatManagementService>;
}

declare abstract class AXMChatRealtimeService {
    abstract readonly room$: Observable<AXMChatRoomEvent>;
    abstract readonly message$: Observable<AXMChatMessageEvent>;
    abstract readonly tab$: Observable<AXMChatTabEvent>;
    abstract readonly typingStatus$: Observable<{
        roomId: string;
        user: AXPUserReference;
        isTyping: boolean;
    }>;
    abstract notifyRoom(event: AXMChatRoomEvent): void;
    abstract notifyMessage(event: AXMChatMessageEvent): void;
    abstract notifyTab(event: AXMChatTabEvent): void;
    abstract startTyping(user: AXPUserReference, roomId: string): void;
    abstract stopTyping(user: AXPUserReference, roomId: string): void;
}
declare class AXMChatRealtimeServiceImpl extends AXMChatRealtimeService {
    private readonly _room$;
    readonly room$: Observable<AXMChatRoomEvent>;
    private readonly _message$;
    readonly message$: Observable<AXMChatMessageEvent>;
    private readonly _tab$;
    readonly tab$: Observable<AXMChatTabEvent>;
    private readonly _typingStatus$;
    readonly typingStatus$: Observable<{
        roomId: string;
        user: AXPUserReference;
        isTyping: boolean;
    }>;
    notifyRoom(event: AXMChatRoomEvent): void;
    notifyMessage(event: AXMChatMessageEvent): void;
    notifyTab(event: AXMChatTabEvent): void;
    startTyping(user: AXPUserReference, roomId: string): void;
    stopTyping(user: AXPUserReference, roomId: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMChatRealtimeServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMChatRealtimeServiceImpl>;
}

declare class AXMChatComponent extends AXPPageLayoutBaseComponent {
    #private;
    private readonly conversationService;
    private readonly router;
    private readonly activatedRoute;
    protected readonly deviceService: AXPDeviceService;
    /**
     * Computed signal to check if there is an active conversation selected.
     */
    readonly hasActiveConversation: i0.Signal<boolean>;
    /**
     * Computed signal to determine if the chat content should be shown.
     * On mobile: show content only when there is an active conversation.
     * On desktop: always show content.
     */
    readonly showContent: i0.Signal<boolean>;
    readonly showChatList: i0.Signal<boolean>;
    /**
     * 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;
    /**
     * Toggles the start side (sidebar) visibility.
     */
    protected toggleStartSide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMChatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AXMChatComponent, "axm-chat", never, {}, {}, never, never, true, never>;
}

declare abstract class AXMChatService {
    abstract createRoom(members: AXPUserReference[], title: string | undefined, currentUser: AXPUserReference, avatar?: string): Promise<AXMConversationRoom>;
    abstract getRoom(roomId: string): Promise<AXMConversationRoom>;
    abstract listRooms(skip?: number, take?: number): Promise<{
        items: AXMConversationRoom[];
        total: number;
    }>;
    abstract updateRoom(roomId: string, data: Partial<AXMConversationRoom>, currentUser: AXPUserReference): Promise<AXMConversationRoom>;
    abstract deleteRoom(roomId: string): Promise<boolean>;
    abstract createTab(data: Omit<AXMConversationTab, 'id'>): Promise<AXMConversationTab>;
    abstract getTab(tabId: string): Promise<AXMConversationTab>;
    abstract listTabs(skip?: number, take?: number): Promise<{
        items: AXMConversationTab[];
        total: number;
    }>;
    abstract updateTab(tabId: string, data: Partial<AXMConversationTab>): Promise<AXMConversationTab>;
    abstract deleteTab(tabId: string): Promise<boolean>;
    abstract sendMessage(roomId: string, content: string, author: AXPUserReference, contentType?: AXPContentType, replyId?: string): Promise<AXMConversationMessage>;
    abstract getMessages(roomId: string, skip?: number, take?: number): Promise<{
        items: AXMConversationMessage[];
        total: number;
    }>;
    abstract getMessage(messageId: string): Promise<AXMConversationMessage>;
    abstract editMessage(messageId: string, content: string, currentUser: AXPUserReference, contentType?: AXPContentType): Promise<AXMConversationMessage>;
    abstract deleteMessage(messageId: string): Promise<boolean>;
    abstract pinMessage(messageId: string, isPinned: boolean, currentUser: AXPUserReference): Promise<AXMConversationMessage>;
    abstract updateReactions(messageId: string, reactions: AXMConversationReaction[], currentUser: AXPUserReference): Promise<AXMConversationMessage>;
    abstract getReactions(messageId: string): Promise<AXMConversationReaction[]>;
    abstract updateSeen(messageId: string, seen: AXMConversationSeen[], currentUser: AXPUserReference): Promise<AXMConversationMessage>;
    abstract getSeenBy(messageId: string): Promise<AXMConversationSeen[]>;
}
declare class AXMChatServiceImpl extends AXMChatService {
    private readonly roomService;
    private readonly messageService;
    private readonly tabService;
    createRoom(members: AXPUserReference[], title: string | undefined, currentUser: AXPUserReference, avatar?: string): Promise<AXMConversationRoom>;
    getRoom(roomId: string): Promise<AXMConversationRoom>;
    listRooms(skip?: number, take?: number): Promise<{
        items: AXMConversationRoom[];
        total: number;
    }>;
    updateRoom(roomId: string, data: Partial<AXMConversationRoom>, currentUser: AXPUserReference): Promise<AXMConversationRoom>;
    deleteRoom(roomId: string): Promise<boolean>;
    createTab(data: Omit<AXMConversationTab, 'id'>): Promise<AXMConversationTab>;
    getTab(tabId: string): Promise<AXMConversationTab>;
    listTabs(skip?: number, take?: number): Promise<{
        items: AXMConversationTab[];
        total: number;
    }>;
    updateTab(tabId: string, data: Partial<AXMConversationTab>): Promise<AXMConversationTab>;
    deleteTab(tabId: string): Promise<boolean>;
    sendMessage(roomId: string, content: string, author: AXPUserReference, contentType?: AXPContentType, replyId?: string): Promise<AXMConversationMessage>;
    getMessages(roomId: string, skip?: number, take?: number): Promise<{
        items: AXMConversationMessage[];
        total: number;
    }>;
    getMessage(messageId: string): Promise<AXMConversationMessage>;
    editMessage(messageId: string, content: string, currentUser: AXPUserReference, contentType?: AXPContentType): Promise<AXMConversationMessage>;
    deleteMessage(messageId: string): Promise<boolean>;
    pinMessage(messageId: string, isPinned: boolean, currentUser: AXPUserReference): Promise<AXMConversationMessage>;
    updateReactions(messageId: string, reactions: AXMConversationReaction[], currentUser: AXPUserReference): Promise<AXMConversationMessage>;
    getReactions(messageId: string): Promise<AXMConversationReaction[]>;
    updateSeen(messageId: string, seen: AXMConversationSeen[], currentUser: AXPUserReference): Promise<AXMConversationMessage>;
    getSeenBy(messageId: string): Promise<AXMConversationSeen[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMChatServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMChatServiceImpl>;
}

declare class AXMCommentManagementService {
    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?: AXPContentType, userId?: string): Promise<AXMComment>;
    getComments(threadId: string, nested: boolean): Promise<AXMComment[]>;
    getComment(commentId: string): Promise<AXMComment>;
    editComment(commentId: string, content: string, contentType?: AXPContentType): Promise<AXMComment>;
    deleteComment(commentId: string): Promise<boolean>;
    addReaction(commentId: string, type: AXMReactionType): Promise<AXMComment>;
    removeReaction(commentId: string, type: AXMReactionType): Promise<AXMComment>;
    getReactions(commentId: string): Promise<AXMConversationReaction[]>;
    likeComment(commentId: string): Promise<AXMComment>;
    unlikeComment(commentId: string): Promise<AXMComment>;
    pinComment(commentId: string): Promise<AXMComment>;
    unpinComment(commentId: string): Promise<AXMComment>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCommentManagementService, never>;
    static ɵprov: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<AXMCommentRealtimeServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCommentRealtimeServiceImpl>;
}

declare class AXMCommentComponent implements OnInit {
    refrenceType: i0.InputSignal<string>;
    refrenceId: i0.InputSignal<string>;
    subject: i0.InputSignal<string>;
    moduleName: i0.WritableSignal<string | undefined>;
    entityName: i0.WritableSignal<string | undefined>;
    protected hasCooldown: i0.WritableSignal<boolean>;
    protected commentContent: i0.WritableSignal<string>;
    protected isSubmitting: i0.WritableSignal<boolean>;
    protected isReplyingMode: i0.WritableSignal<boolean>;
    protected isEditingMode: i0.WritableSignal<boolean>;
    protected isLoading: i0.WritableSignal<boolean>;
    protected failedImageIds: i0.WritableSignal<string[]>;
    protected activeReplyComment: i0.WritableSignal<(AXMComment & {
        userName: string;
    }) | undefined>;
    protected activeEditComment: i0.WritableSignal<(AXMComment & {
        userName: string;
    }) | undefined>;
    protected highlightedCommentId: i0.WritableSignal<string | null>;
    protected wysiwygEditor: i0.Signal<AXWysiwygContainerComponent>;
    private commentService;
    private realtimeService;
    private sessionService;
    private toastService;
    private dialogService;
    private notificationConnectorService;
    private router;
    private activatedRoute;
    sanitize: DomSanitizer;
    private destroyRef;
    protected comments: i0.WritableSignal<AXMComment[]>;
    protected thread: i0.WritableSignal<AXMCommentThread | undefined>;
    ngOnInit(): void;
    private handleAddComment;
    private handleUpdateComment;
    protected wysiwygOptions: i0.WritableSignal<{
        look: AXStyleLookType;
    }>;
    protected avatarConfig: i0.WritableSignal<{
        color: string;
        look: "sharp" | "soft" | "rounded";
        type: string;
    }>;
    private getCurrentUser;
    protected isLikedByUser(comment: AXMComment): boolean;
    protected getReactionsCount(comment: AXMComment): number;
    sanitizeHtml(htmlContent: string | undefined): _angular_platform_browser.SafeHtml;
    handleImageError(imageId: string): void;
    checkImageExists(imageId: string): boolean;
    loadComments(): Promise<void>;
    editMessage(comment: AXMComment, reply?: AXMComment, userName?: string): void;
    replyMessage(comment: AXMComment, reply?: AXMComment, userName?: string): void;
    deleteComment(commentId: string): Promise<void>;
    resetReplyEditState(): void;
    toggleLike(comment: AXMComment): Promise<void>;
    private updateLikeStatus;
    private removeMessageById;
    protected submitComment(): Promise<void>;
    scrollMain(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCommentComponent, never>;
    static ɵcmp: i0.ɵɵ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>;
}

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?: AXPContentType, 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?: AXPContentType): Promise<AXMComment>;
    abstract deleteComment(commentId: string): Promise<boolean>;
    abstract addReaction(commentId: string, type: AXMReactionType): Promise<AXMComment>;
    abstract removeReaction(commentId: string, type: AXMReactionType): Promise<AXMComment>;
    abstract getReactions(commentId: string): Promise<AXMConversationReaction[]>;
    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 roomService;
    private readonly messageService;
    private readonly filterService;
    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?: AXPContentType): Promise<AXMConversationMessage>;
    getComments(threadId: string): Promise<AXMConversationMessage[]>;
    getComment(commentId: string): Promise<AXMConversationMessage>;
    editComment(commentId: string, content: string, editor: AXPUserReference, contentType?: AXPContentType): Promise<AXMConversationMessage>;
    deleteComment(commentId: string): Promise<boolean>;
    updateReactions(commentId: string, reactions: AXMConversationReaction[]): Promise<AXMConversationMessage>;
    getReactions(commentId: string): Promise<AXMConversationReaction[]>;
    pinComment(commentId: string, isPinned: boolean): Promise<AXMConversationMessage>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCommentServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCommentServiceImpl>;
}

declare class AXMCommentPopupComponent extends AXBasePageComponent {
    refrenceType: i0.InputSignal<string>;
    refrenceId: i0.InputSignal<string>;
    subject: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCommentPopupComponent, never>;
    static ɵcmp: i0.ɵɵ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: i0.Signal<any>;
    protected refrenceId: i0.Signal<any>;
    protected subject: i0.Signal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCommentWidgetViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AXMCommentWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare const AXPCommentWidget: AXPWidgetConfig;

declare class AXMCommentPopupStartAction extends AXPWorkflowAction {
    private popupService;
    private translate;
    execute(context: AXPWorkflowContext): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMCommentPopupStartAction, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMCommentPopupStartAction>;
}
declare const AXMCommentPopupWorkflow: AXPWorkflow;

export { AXMChatComponent, AXMChatManagementService, AXMChatRealtimeService, AXMChatRealtimeServiceImpl, AXMChatService, AXMChatServiceImpl, AXMCommentComponent, AXMCommentManagementService, AXMCommentPopupComponent, AXMCommentPopupStartAction, AXMCommentPopupWorkflow, AXMCommentRealtimeService, AXMCommentRealtimeServiceImpl, AXMCommentService, AXMCommentServiceImpl, AXMCommentWidgetViewComponent, AXMConversationModule, AXMConversationTabEntityModule, AXMConversationTabService, AXMConversationTabServiceImpl, AXMMessageEntityModule, AXMMessageService, AXMMessageServiceImpl, AXMRoomEntityModule, AXMRoomService, AXMRoomServiceImpl, AXPCommentWidget, RootConfig, messageFactory, roomFactory, tabFactory };
export type { AXMChatMessage, AXMChatMessageEvent, AXMChatRoom, AXMChatRoomEvent, AXMChatTabEvent, AXMComment, AXMCommentEntityData, AXMCommentEvent, AXMCommentEventType, AXMCommentThread, AXMConversationMessage, AXMConversationReaction, AXMConversationRoom, AXMConversationSeen, AXMConversationTab, AXMReactionType, AXMSeenType, AXMThreadEvent, AXMThreadEventType };
