import { Observable } from 'rxjs';
import { Conversation, ConversationType, CreateConversationRequest, ListConversationsResponse, Message, MessageAttachment, UpdateConversationRequest } from './types';
import * as i0 from "@angular/core";
/**
 * ConversationService
 *
 * Gestiona conversaciones y mensajes del chat.
 *
 * Dos capas:
 *   - HTTP (via backend /v2/chat/*): operaciones de escritura y consulta.
 *   - Firestore real-time (directa): escucha mensajes y estado de escritura.
 *
 * Paths Firestore:
 *   /apps/{appId}/orgs/{orgId}/conversations/{convId}/messages/{msgId}
 *   /apps/{appId}/orgs/{orgId}/conversations/{convId}/typing/{userId}
 *
 * @example
 * // Enviar y escuchar mensajes
 * const svc = inject(ConversationService);
 *
 * // Enviar (HTTP)
 * svc.sendMessage(convId, 'Hola!').subscribe();
 *
 * // Escuchar en tiempo real (Firestore)
 * svc.watchMessages(convId, orgId, appId).subscribe(msgs => this.messages.set(msgs));
 */
export declare class ConversationService {
    private config;
    private http;
    private firestoreService;
    private firestore;
    constructor();
    private get baseUrl();
    /**
     * Crea una nueva conversacion.
     * El backend responde con un envelope { operationId, conversation } — lo
     * desenvolvemos para devolver la Conversation directa.
     */
    createConversation(req: CreateConversationRequest): Observable<Conversation>;
    /**
     * Obtiene o crea una conversacion asociada a una entidad (post, request, org, etc.).
     * Usa el patron upsert del backend: si ya existe una conversacion para esa entidad,
     * la devuelve; si no, la crea.
     *
     * El backend espera { entityRef: { type, id }, type } y responde con un envelope
     * { operationId, conversation, created }.
     */
    getOrCreateForEntity(entityType: string, entityId: string, type?: ConversationType): Observable<Conversation>;
    /**
     * Lista las conversaciones del usuario autenticado.
     */
    listConversations(cursor?: string): Observable<ListConversationsResponse>;
    /**
     * Obtiene una conversacion por ID.
     */
    getConversation(convId: string): Observable<Conversation>;
    /**
     * Actualiza el nombre o settings de una conversacion.
     */
    updateConversation(convId: string, req: UpdateConversationRequest): Observable<Conversation>;
    /**
     * Abre una conversacion cerrada.
     */
    openConversation(convId: string): Observable<void>;
    /**
     * Cierra una conversacion.
     */
    closeConversation(convId: string): Observable<void>;
    /**
     * Agrega un participante a la conversacion.
     */
    addParticipant(convId: string, userId: string): Observable<void>;
    /**
     * Elimina un participante de la conversacion.
     */
    removeParticipant(convId: string, userId: string): Observable<void>;
    /**
     * Envia un mensaje a una conversacion, opcionalmente con adjuntos.
     * El backend espera `attachments: { url, type, name, size }[]` (key `type` = MIME),
     * mientras que el front usa `mimeType` — se mapea aqui.
     */
    sendMessage(convId: string, body: string, attachments?: MessageAttachment[]): Observable<Message>;
    /**
     * Elimina (marca como eliminado) un mensaje.
     */
    deleteMessage(convId: string, msgId: string): Observable<void>;
    /**
     * Construye el path base para los datos de una conversacion.
     * Nota: usamos el path completo con skipPrefix porque el path ya incluye
     * apps/{appId}/orgs/{orgId} que el FirestoreService prefijaria de nuevo.
     * En cambio armamos el path como sub-coleccion directamente.
     */
    private convMessagesPath;
    private convTypingPath;
    /**
     * Escucha los mensajes de una conversacion en tiempo real.
     *
     * @param convId - ID de la conversacion
     * @param orgId - ID de la organizacion
     * @param appId - ID de la aplicacion
     * @param limit - Cantidad maxima de mensajes a cargar (default 50)
     */
    watchMessages(convId: string, orgId: string, appId: string, limit?: number): Observable<Message[]>;
    /**
     * Escucha los usuarios que estan escribiendo en una conversacion.
     * Devuelve un array de displayNames.
     *
     * @param convId - ID de la conversacion
     * @param orgId - ID de la organizacion
     * @param appId - ID de la aplicacion
     */
    watchTyping(convId: string, orgId: string, appId: string): Observable<string[]>;
    /**
     * Registra que el usuario actual esta escribiendo.
     * El documento se sobreescribe para actualizar el timestamp.
     * Debe llamarse con un TTL/cleanup (ver stopTyping).
     *
     * @param convId - ID de la conversacion
     * @param orgId - ID de la organizacion
     * @param appId - ID de la aplicacion
     * @param displayName - Nombre visible del usuario
     */
    startTyping(convId: string, orgId: string, appId: string, displayName: string): void;
    /**
     * Elimina el documento de "escribiendo" del usuario actual.
     *
     * @param convId - ID de la conversacion
     * @param orgId - ID de la organizacion
     * @param appId - ID de la aplicacion
     */
    stopTyping(convId: string, orgId: string, appId: string): void;
    /**
     * Marca un mensaje como leido por el usuario actual.
     * Escribe directamente en Firestore sin pasar por el backend.
     *
     * @param convId - ID de la conversacion
     * @param msgId - ID del ultimo mensaje leido
     * @param orgId - ID de la organizacion
     * @param appId - ID de la aplicacion
     */
    markRead(convId: string, msgId: string, orgId: string, appId: string): void;
    /**
     * Importa ABS_PATH_SENTINEL de forma lazy para evitar dependencias circulares.
     */
    private getAbsPathSentinel;
    /**
     * Obtiene el userId del usuario actual desde sessionStorage / localStorage
     * como fallback no-DI para el contexto de escritura de Firestore.
     * En prod, el AuthService actualiza el userId en el contexto de la app.
     */
    private getCurrentUserId;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConversationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConversationService>;
}