@antzsoft/chat-core 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,852 @@
+import { AxiosInstance } from 'axios';
+import { Socket } from 'socket.io-client';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+
+type EncryptionMode = 'none' | 'server' | 'e2ee';
+type FileType = 'image' | 'video' | 'audio' | 'document';
+type ConversationType = 'direct' | 'group';
+type MessageStatus = 'sent' | 'delivered' | 'read' | 'failed' | 'deleted';
+type DeliveryStatus = 'sending' | 'sent' | 'delivered' | 'read' | 'failed';
+type UserStatus = 'online' | 'offline' | 'away';
+type ParticipantRole = 'admin' | 'member';
+/**
+ * Platform-agnostic file descriptor.
+ * - Web: built from a browser File object ({ uri: URL.createObjectURL(f), name: f.name, type: f.type, size: f.size })
+ * - React Native: built from document/image picker result ({ uri: result.uri, name: result.name, type: result.mimeType, size: result.size })
+ */
+interface UploadableFile {
+    /** Local URI — blob URL on web, file:// URI on RN */
+    uri: string;
+    name: string;
+    /** MIME type, e.g. "image/jpeg" */
+    type: string;
+    size: number;
+}
+interface User {
+    id: string;
+    tenantId: string;
+    email: string;
+    username: string;
+    displayName: string;
+    avatarUrl?: string;
+    phone?: string;
+    status: UserStatus;
+    lastSeenAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+    tokenType: string;
+    expiresIn: number;
+}
+interface AuthResponse {
+    user: User;
+    tokens: AuthTokens;
+}
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+interface RegisterData {
+    email: string;
+    password: string;
+    username: string;
+    displayName: string;
+    phone?: string;
+    tenantId?: string;
+}
+interface Attachment {
+    id: string;
+    type: FileType;
+    url: string;
+    thumbnailUrl?: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+    duration?: number;
+    isUploading?: boolean;
+    uploadProgress?: number;
+}
+interface EncryptedContent {
+    ciphertext: string;
+    iv: string;
+    tag: string;
+    algorithm: 'aes-256-gcm';
+}
+interface EncryptionKeyInfo {
+    key: string;
+    enabled: boolean;
+    mode: EncryptionMode;
+}
+interface MessageReaction {
+    emoji: string;
+    userIds: string[];
+    count: number;
+}
+interface MessageContent {
+    text?: string;
+    type: 'text' | 'attachment' | 'system';
+    attachments?: Attachment[];
+}
+interface MessageReplyReference {
+    messageId?: string;
+    contentPreview?: string;
+    senderName?: string;
+    id?: string;
+    content?: MessageContent;
+    sender?: Pick<User, 'displayName' | 'avatarUrl'>;
+}
+interface Message {
+    id: string;
+    tenantId: string;
+    conversationId: string;
+    senderId: string;
+    content: MessageContent;
+    replyTo?: MessageReplyReference;
+    reactions: MessageReaction[];
+    status: MessageStatus;
+    deliveryStatus?: DeliveryStatus;
+    isEdited: boolean;
+    editedAt?: string;
+    isStarred?: boolean;
+    isPinned?: boolean;
+    pinnedBy?: string;
+    pinnedAt?: string;
+    uploadProgress?: number;
+    sentAt: string;
+    createdAt: string;
+    sender?: User;
+    readBy?: string[];
+    isEncrypted?: boolean;
+    encryptionMode?: EncryptionMode;
+    encryptedContent?: EncryptedContent;
+}
+interface Participant {
+    userId: string;
+    role: ParticipantRole;
+    joinedAt: string;
+    isActive?: boolean;
+    user?: User;
+}
+interface ConversationSettings {
+    onlyAdminsCanMessage?: boolean;
+    onlyAdminsCanAddMembers?: boolean;
+}
+interface Conversation {
+    id: string;
+    tenantId: string;
+    conversationType: ConversationType;
+    name?: string;
+    description?: string;
+    icon?: string;
+    iconUrl?: string;
+    participants: Participant[];
+    participantCount?: number;
+    settings?: ConversationSettings;
+    lastMessage?: Message;
+    createdBy?: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    unreadCount?: number;
+    isPinned?: boolean;
+    isMuted?: boolean;
+    mutedUntil?: string;
+    encryptionMode?: EncryptionMode;
+    isEncryptionEnabled?: boolean;
+    encryptionKey?: string;
+}
+interface PaginationMeta {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+interface CursorPaginationMeta {
+    hasMore: boolean;
+    nextCursor?: string;
+    prevCursor?: string;
+}
+interface CursorPaginatedResponse<T> {
+    data: T[];
+    meta: CursorPaginationMeta;
+}
+interface PresignedUrlRequest {
+    filename: string;
+    mimeType: string;
+    size: number;
+    conversationId?: string;
+    folder?: string;
+}
+interface PresignedUrlResponse {
+    fileId: string;
+    uploadUrl: string;
+    method: 'PUT' | 'POST';
+    headers: Record<string, string>;
+    fields?: Record<string, string>;
+    expiresAt: string;
+    maxSize: number;
+    allowedMimeType: string;
+}
+interface FileResponse {
+    id: string;
+    filename: string;
+    originalFilename: string;
+    mimeType: string;
+    size: number;
+    url: string;
+    thumbnailUrl?: string;
+    type: FileType;
+    uploadedAt?: string;
+    confirmedAt?: string;
+}
+interface UploadProgress {
+    fileId: string;
+    filename: string;
+    progress: number;
+    status: 'pending' | 'uploading' | 'confirming' | 'done' | 'error';
+    error?: string;
+}
+interface BatchUploadResult {
+    successful: FileResponse[];
+    failed: Array<{
+        filename: string;
+        error: string;
+    }>;
+}
+interface NewMessageEvent {
+    tempId?: string;
+    senderName?: string;
+    senderAvatarUrl?: string;
+    message: Message;
+}
+interface MessageUpdatedEvent {
+    messageId: string;
+    conversationId: string;
+    text: string;
+    editedAt: string;
+}
+interface MessageDeletedEvent {
+    messageId: string;
+    conversationId: string;
+}
+interface ReactionUpdatedEvent {
+    messageId: string;
+    conversationId: string;
+    reactions: MessageReaction[];
+}
+interface TypingIndicatorEvent {
+    conversationId: string;
+    userId: string;
+    username: string;
+    displayName: string;
+    avatarUrl?: string;
+    isTyping: boolean;
+}
+interface UserStatusEvent {
+    userId: string;
+    status: UserStatus;
+    lastSeenAt?: string;
+}
+interface ReadReceiptEvent {
+    conversationId: string;
+    messageId: string;
+    userId: string;
+    readAt: string;
+    updatedMessageIds?: string[];
+    fullyReadMessageIds?: string[];
+}
+interface MessageAckEvent {
+    tempId: string;
+    messageId: string;
+    status: MessageStatus;
+}
+interface MessageDeliveredEvent {
+    messageId: string;
+    conversationId: string;
+    deliveredAt: string;
+}
+interface MessagesDeliveredEvent {
+    conversationId: string;
+    messageIds: string[];
+    deliveredTo: string;
+    deliveredAt: string;
+}
+interface SendMessageAttachment {
+    fileId: string;
+    type: FileType;
+    url: string;
+    thumbnailUrl?: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+}
+interface OptimisticAttachment extends SendMessageAttachment {
+    id: string;
+    url: string;
+    thumbnailUrl?: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    isUploading?: boolean;
+    uploadProgress?: number;
+}
+interface SendMessagePayload {
+    conversationId: string;
+    text?: string;
+    attachments?: SendMessageAttachment[];
+    replyTo?: string;
+    tempId: string;
+    encryptedContent?: EncryptedContent;
+    isEncrypted?: boolean;
+}
+
+interface FileSizeLimits {
+    image?: number;
+    video?: number;
+    audio?: number;
+    document?: number;
+    default?: number;
+}
+/**
+ * Platform-provided function that performs the actual binary upload to a presigned URL.
+ * - Web implementation: XMLHttpRequest with progress events
+ * - RN implementation: fetch with FormData or direct body
+ *
+ * The core calls this — it never does the upload itself.
+ */
+type PlatformUploadFn = (presigned: PresignedUrlResponse, file: UploadableFile, onProgress?: (pct: number) => void) => Promise<void>;
+/**
+ * Platform-provided persistent key-value storage for auth token persistence.
+ * - Web: localStorage adapter
+ * - RN: AsyncStorage adapter
+ */
+interface PersistStorage {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+interface UploadConfig {
+    /**
+     * Per-type file size limits in MB. Can also pass a single number for all types.
+     * Defaults: image 5MB, video 25MB, audio 10MB, document 10MB.
+     */
+    maxFileSizeMB?: number | FileSizeLimits;
+    /** Max files per message. Default: 10 */
+    maxFilesPerMessage?: number;
+    /** Which attachment types users can send. Default: all */
+    allowedTypes?: Array<FileType>;
+    /** Called when a file fails validation or upload */
+    onUploadError?: (file: UploadableFile, error: Error) => void;
+    /** Called with 0–100 aggregate progress during a batch upload */
+    onProgress?: (progress: number) => void;
+}
+interface AntzChatConfig {
+    /** REST API base URL — e.g. "https://api.yourapp.com/api/v1" */
+    apiUrl: string;
+    /**
+     * WebSocket server URL. Defaults to apiUrl with /api/vN path stripped.
+     * SDK connects to {socketUrl}/chat
+     */
+    socketUrl?: string;
+    /** Static JWT. Use this OR authProvider, not both. */
+    authToken?: string;
+    /**
+     * Dynamic token getter — called before requests and on socket reconnect.
+     * Preferred when the host app manages its own auth lifecycle.
+     */
+    authProvider?: () => Promise<string>;
+    /**
+     * External user ID — required for non-builtin modes (antz / external / wso2).
+     * Sent as x-user-id header on every request so the chat server can forward it
+     * to the user-service for token validation.
+     * Not needed for builtin mode (chat server issues its own JWTs).
+     */
+    userId?: string;
+    /** Required for multi-tenant backends. Sent as X-Tenant-ID header. */
+    tenantId?: string;
+    /** Must match server ENCRYPTION_MODE env var. Default: 'none' */
+    encryptionMode?: 'none' | 'server';
+    upload?: UploadConfig;
+    /**
+     * Platform-specific binary upload implementation.
+     * Required — each SDK (web, RN) provides its own.
+     */
+    platformUploadFn: PlatformUploadFn;
+    /**
+     * Platform-specific persistent storage for auth tokens.
+     * Required — each SDK provides its own (localStorage / AsyncStorage).
+     */
+    persistStorage: PersistStorage;
+}
+interface ResolvedFileSizeLimits {
+    image: number;
+    video: number;
+    audio: number;
+    document: number;
+    default: number;
+}
+interface ResolvedConfig {
+    apiUrl: string;
+    socketUrl: string;
+    authToken?: string;
+    authProvider?: () => Promise<string>;
+    userId?: string;
+    tenantId?: string;
+    encryptionMode: 'none' | 'server';
+    upload: {
+        maxFileSizeMB: ResolvedFileSizeLimits;
+        maxFilesPerMessage: number;
+        allowedTypes: FileType[];
+        onUploadError?: (file: UploadableFile, error: Error) => void;
+        onProgress?: (progress: number) => void;
+    };
+    platformUploadFn: PlatformUploadFn;
+    persistStorage: PersistStorage;
+}
+declare function resolveConfig(config: AntzChatConfig): ResolvedConfig;
+
+declare const authApi: {
+    login(credentials: LoginCredentials): Promise<AuthResponse>;
+    register(payload: RegisterData): Promise<AuthResponse>;
+    refresh(refreshToken: string): Promise<AuthTokens>;
+    logout(refreshToken?: string): Promise<void>;
+    logoutAll(): Promise<void>;
+    getMe(): Promise<User>;
+};
+
+interface ListMessagesParams {
+    cursor?: string;
+    limit?: number;
+    direction?: 'before' | 'after';
+}
+interface SearchParams {
+    query: string;
+    conversationId?: string;
+    page?: number;
+    limit?: number;
+}
+interface SendData {
+    text?: string;
+    attachments?: SendMessagePayload['attachments'];
+    replyTo?: string;
+    tempId?: string;
+    isEncrypted?: boolean;
+}
+declare const messagesApi: {
+    list(conversationId: string, params?: ListMessagesParams): Promise<CursorPaginatedResponse<Message>>;
+    get(messageId: string): Promise<Message>;
+    send(conversationId: string, payload: SendData): Promise<Message>;
+    update(messageId: string, text: string): Promise<Message>;
+    delete(messageId: string): Promise<void>;
+    addReaction(messageId: string, emoji: string): Promise<Message>;
+    removeReaction(messageId: string, emoji: string): Promise<Message>;
+    star(messageId: string): Promise<void>;
+    unstar(messageId: string): Promise<void>;
+    getStarred(params?: {
+        page?: number;
+        limit?: number;
+        conversationId?: string;
+    }): Promise<PaginatedResponse<Message>>;
+    search(params: SearchParams): Promise<PaginatedResponse<Message>>;
+    markAsRead(conversationId: string, messageId?: string): Promise<void>;
+    pin(messageId: string): Promise<Message>;
+    unpin(messageId: string): Promise<Message>;
+    getPinned(conversationId: string): Promise<Message[]>;
+};
+
+declare function normalizeConversation(conv: any): Conversation;
+interface CreateGroupData {
+    name: string;
+    description?: string;
+    icon?: string;
+    participantIds: string[];
+}
+interface CreateDirectData {
+    userId: string;
+}
+interface UpdateConversationData {
+    name?: string;
+    description?: string;
+    icon?: string;
+}
+declare const conversationsApi: {
+    list(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResponse<Conversation>>;
+    get(conversationId: string): Promise<Conversation>;
+    createGroup(payload: CreateGroupData): Promise<Conversation>;
+    createDirect(payload: CreateDirectData): Promise<Conversation>;
+    update(conversationId: string, payload: UpdateConversationData): Promise<Conversation>;
+    delete(conversationId: string): Promise<void>;
+    addParticipants(conversationId: string, userIds: string[]): Promise<Conversation>;
+    removeParticipant(conversationId: string, userId: string): Promise<Conversation>;
+    updateParticipantRole(conversationId: string, userId: string, role: "admin" | "member"): Promise<Conversation>;
+    mute(conversationId: string, mutedUntil?: string): Promise<void>;
+    unmute(conversationId: string): Promise<void>;
+    pin(conversationId: string): Promise<void>;
+    unpin(conversationId: string): Promise<void>;
+    leave(conversationId: string): Promise<void>;
+    getMembers(conversationId: string): Promise<User[]>;
+    searchUsers(query: string): Promise<User[]>;
+};
+
+declare const storageApi: {
+    requestPresignedUrl(payload: PresignedUrlRequest): Promise<PresignedUrlResponse>;
+    requestPresignedUrlBatch(files: PresignedUrlRequest[]): Promise<{
+        urls: PresignedUrlResponse[];
+        errors: Array<{
+            filename: string;
+            error: string;
+        }>;
+    }>;
+    confirmUpload(fileId: string): Promise<FileResponse>;
+    getFile(fileId: string): Promise<FileResponse>;
+    getFileUrl(fileId: string, expiresIn?: number): Promise<{
+        url: string;
+        expiresAt: string;
+    }>;
+    deleteFile(fileId: string): Promise<void>;
+    getConversationFiles(conversationId: string, params?: {
+        page?: number;
+        limit?: number;
+        type?: FileType;
+    }): Promise<PaginatedResponse<FileResponse>>;
+    getMyFiles(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResponse<FileResponse>>;
+};
+/**
+ * High-level batch upload.
+ * The actual binary transfer is delegated to platformUploadFn so this
+ * function is platform-agnostic (works on web and React Native).
+ */
+declare function uploadBatch(files: UploadableFile[], platformUploadFn: PlatformUploadFn, conversationId?: string, onProgress?: (pct: number) => void): Promise<BatchUploadResult>;
+
+/** Shared fields for every device registration. */
+interface DeviceTokenBase {
+    /**
+     * Client-generated stable UUID for this device.
+     * Store this in localStorage / SecureStore / Keychain and reuse it on every
+     * app start so the same record is updated rather than duplicated.
+     */
+    deviceId: string;
+    platform: 'ios' | 'android' | 'web';
+    provider: 'expo' | 'fcm' | 'apns' | 'web-push';
+    userAgent?: string;
+}
+/** Mobile push registration (expo | fcm | apns). */
+interface MobileDeviceToken extends DeviceTokenBase {
+    provider: 'expo' | 'fcm' | 'apns';
+    /** FCM registration token / APNs device token / Expo push token. */
+    token: string;
+    endpoint?: never;
+    p256dh?: never;
+    auth?: never;
+}
+/** Web push (VAPID) registration. */
+interface WebPushDeviceToken extends DeviceTokenBase {
+    provider: 'web-push';
+    /** PushSubscription.endpoint */
+    endpoint: string;
+    /** base64url-encoded PushSubscription key 'p256dh' */
+    p256dh: string;
+    /** base64url-encoded PushSubscription key 'auth' */
+    auth: string;
+    token?: never;
+}
+type RegisterDeviceTokenPayload = MobileDeviceToken | WebPushDeviceToken;
+declare const devicesApi: {
+    /**
+     * Register or update a device push token with the chat server.
+     *
+     * Upserts by `deviceId` — calling this multiple times with the same deviceId
+     * simply refreshes the token value (tokens can rotate silently on some platforms).
+     *
+     * The SDK never calls this automatically. The parent app or the `tokenProvider`
+     * option in `pushNotifications` config is responsible for calling it after
+     * obtaining the token from the OS / browser.
+     */
+    register(payload: RegisterDeviceTokenPayload): Promise<void>;
+    /**
+     * Remove a device token from the chat server.
+     * Call this on logout so the user stops receiving push notifications on this device.
+     */
+    remove(deviceId: string): Promise<void>;
+};
+
+type TokenStore = {
+    getAccessToken: () => string | null | undefined;
+    getRefreshToken: () => string | null | undefined;
+    setTokens: (tokens: AuthTokens) => void;
+    clearTokens: () => void;
+};
+declare function initApiClient(config: ResolvedConfig, tokenStore: TokenStore): AxiosInstance;
+declare function setApiClientInstance(instance: AxiosInstance): void;
+declare function getApiClient(): AxiosInstance;
+
+type SocketStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+type StatusListener = (status: SocketStatus) => void;
+declare function getSocket(): Socket;
+/** Returns the socket if connected, null otherwise. Use this for fire-and-forget
+ *  operations (markRead, typing) that should silently no-op when not yet connected. */
+declare function tryGetSocket(): Socket | null;
+declare function getSocketStatus(): SocketStatus;
+declare function onSocketStatus(listener: StatusListener): () => void;
+declare function connectSocket(config: ResolvedConfig, getToken: () => string | null | undefined): Promise<Socket>;
+declare function disconnectSocket(): void;
+declare function reconnectSocket(token: string): void;
+
+declare const socketEmit: {
+    joinRoom(conversationId: string): void;
+    leaveRoom(conversationId: string): void;
+    sendMessage(payload: SendMessagePayload): Promise<unknown>;
+    updateMessage(messageId: string, text: string): Promise<unknown>;
+    deleteMessage(messageId: string): Promise<unknown>;
+    addReaction(messageId: string, emoji: string): Promise<unknown>;
+    removeReaction(messageId: string, emoji: string): Promise<unknown>;
+    pinMessage(messageId: string): Promise<unknown>;
+    unpinMessage(messageId: string): Promise<unknown>;
+    typing(conversationId: string, isTyping: boolean): void;
+    markRead(conversationId: string, messageId?: string): void;
+    getOnlineUsers(userIds: string[]): Promise<string[]>;
+    getTypingUsers(conversationId: string): Promise<unknown>;
+};
+
+interface AuthState {
+    user: User | null;
+    tokens: AuthTokens | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isHydrated: boolean;
+    setAuth: (user: User, tokens: AuthTokens) => void;
+    setTokens: (tokens: AuthTokens) => void;
+    setUser: (user: User) => void;
+    logout: () => void;
+    setLoading: (loading: boolean) => void;
+    setHydrated: (hydrated: boolean) => void;
+}
+/**
+ * Creates a platform-specific auth store.
+ * Call once during SDK init with the platform's PersistStorage adapter.
+ * - Web: pass a localStorage adapter
+ * - RN: pass an AsyncStorage adapter
+ */
+declare function createAuthStore(storage: PersistStorage): {
+    useAuthStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AuthState>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<zustand_middleware.PersistOptions<AuthState, AuthState>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: AuthState) => void) => () => void;
+            onFinishHydration: (fn: (state: AuthState) => void) => () => void;
+            getOptions: () => Partial<zustand_middleware.PersistOptions<AuthState, AuthState>>;
+        };
+    }>;
+    authTokenStore: {
+        getAccessToken: () => string | undefined;
+        getRefreshToken: () => string | undefined;
+        setTokens: (tokens: AuthTokens) => void;
+        clearTokens: () => void;
+    };
+};
+/**
+ * Initialize the auth store singleton.
+ * Idempotent — subsequent calls with the same storage return the existing instance.
+ * This ensures tokens persisted in localStorage/AsyncStorage survive re-renders
+ * and React StrictMode double-invocations.
+ */
+declare function initAuthStore(storage: PersistStorage): {
+    useAuthStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AuthState>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<zustand_middleware.PersistOptions<AuthState, AuthState>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: AuthState) => void) => () => void;
+            onFinishHydration: (fn: (state: AuthState) => void) => () => void;
+            getOptions: () => Partial<zustand_middleware.PersistOptions<AuthState, AuthState>>;
+        };
+    }>;
+    authTokenStore: {
+        getAccessToken: () => string | undefined;
+        getRefreshToken: () => string | undefined;
+        setTokens: (tokens: AuthTokens) => void;
+        clearTokens: () => void;
+    };
+};
+declare function getAuthStore(): {
+    useAuthStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AuthState>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<zustand_middleware.PersistOptions<AuthState, AuthState>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: AuthState) => void) => () => void;
+            onFinishHydration: (fn: (state: AuthState) => void) => () => void;
+            getOptions: () => Partial<zustand_middleware.PersistOptions<AuthState, AuthState>>;
+        };
+    }>;
+    authTokenStore: {
+        getAccessToken: () => string | undefined;
+        getRefreshToken: () => string | undefined;
+        setTokens: (tokens: AuthTokens) => void;
+        clearTokens: () => void;
+    };
+};
+/** Reset the singleton — only for tests / SDK teardown. */
+declare function resetAuthStore(): void;
+
+interface TypingUser {
+    userId: string;
+    displayName: string;
+    avatarUrl?: string;
+}
+interface ChatState {
+    activeConversationId: string | null;
+    pendingTarget: {
+        conversationId: string;
+        messageId: string;
+    } | null;
+    typingUsers: Record<string, TypingUser[]>;
+    onlineUsers: string[];
+    replyingTo: Message | null;
+    editingMessage: Message | null;
+    isSidebarOpen: boolean;
+    isGroupInfoOpen: boolean;
+    isStarredPanelOpen: boolean;
+    setActiveConversation: (id: string | null) => void;
+    setPendingTarget: (target: {
+        conversationId: string;
+        messageId: string;
+    } | null) => void;
+    addTypingUser: (conversationId: string, user: TypingUser) => void;
+    removeTypingUser: (conversationId: string, userId: string) => void;
+    setUserOnline: (userId: string) => void;
+    setUserOffline: (userId: string) => void;
+    setOnlineUsers: (userIds: string[]) => void;
+    setReplyingTo: (message: Message | null) => void;
+    setEditingMessage: (message: Message | null) => void;
+    toggleSidebar: () => void;
+    setSidebarOpen: (open: boolean) => void;
+    toggleGroupInfo: () => void;
+    setGroupInfoOpen: (open: boolean) => void;
+    toggleStarredPanel: () => void;
+    setStarredPanelOpen: (open: boolean) => void;
+}
+declare const useChatStore: zustand.UseBoundStore<zustand.StoreApi<ChatState>>;
+
+interface ClientSocketHandle {
+    emit: typeof socketEmit;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+}
+/**
+ * Headless client for non-React consumers or direct programmatic use.
+ * Usage:
+ *   const client = new AntzChatClient({ apiUrl, authToken, platformUploadFn, persistStorage })
+ *   await client.connect()
+ */
+declare class AntzChatClient {
+    private _config;
+    private _authStore;
+    readonly auth: {
+        login(credentials: LoginCredentials): Promise<AuthResponse>;
+        register(payload: RegisterData): Promise<AuthResponse>;
+        refresh(refreshToken: string): Promise<AuthTokens>;
+        logout(refreshToken?: string): Promise<void>;
+        logoutAll(): Promise<void>;
+        getMe(): Promise<User>;
+    };
+    readonly messages: {
+        list(conversationId: string, params?: ListMessagesParams): Promise<CursorPaginatedResponse<Message>>;
+        get(messageId: string): Promise<Message>;
+        send(conversationId: string, payload: SendData): Promise<Message>;
+        update(messageId: string, text: string): Promise<Message>;
+        delete(messageId: string): Promise<void>;
+        addReaction(messageId: string, emoji: string): Promise<Message>;
+        removeReaction(messageId: string, emoji: string): Promise<Message>;
+        star(messageId: string): Promise<void>;
+        unstar(messageId: string): Promise<void>;
+        getStarred(params?: {
+            page?: number;
+            limit?: number;
+            conversationId?: string;
+        }): Promise<PaginatedResponse<Message>>;
+        search(params: SearchParams): Promise<PaginatedResponse<Message>>;
+        markAsRead(conversationId: string, messageId?: string): Promise<void>;
+        pin(messageId: string): Promise<Message>;
+        unpin(messageId: string): Promise<Message>;
+        getPinned(conversationId: string): Promise<Message[]>;
+    };
+    readonly conversations: {
+        list(params?: {
+            page?: number;
+            limit?: number;
+        }): Promise<PaginatedResponse<Conversation>>;
+        get(conversationId: string): Promise<Conversation>;
+        createGroup(payload: CreateGroupData): Promise<Conversation>;
+        createDirect(payload: CreateDirectData): Promise<Conversation>;
+        update(conversationId: string, payload: UpdateConversationData): Promise<Conversation>;
+        delete(conversationId: string): Promise<void>;
+        addParticipants(conversationId: string, userIds: string[]): Promise<Conversation>;
+        removeParticipant(conversationId: string, userId: string): Promise<Conversation>;
+        updateParticipantRole(conversationId: string, userId: string, role: "admin" | "member"): Promise<Conversation>;
+        mute(conversationId: string, mutedUntil?: string): Promise<void>;
+        unmute(conversationId: string): Promise<void>;
+        pin(conversationId: string): Promise<void>;
+        unpin(conversationId: string): Promise<void>;
+        leave(conversationId: string): Promise<void>;
+        getMembers(conversationId: string): Promise<User[]>;
+        searchUsers(query: string): Promise<User[]>;
+    };
+    readonly storage: {
+        requestPresignedUrl(payload: PresignedUrlRequest): Promise<PresignedUrlResponse>;
+        requestPresignedUrlBatch(files: PresignedUrlRequest[]): Promise<{
+            urls: PresignedUrlResponse[];
+            errors: Array<{
+                filename: string;
+                error: string;
+            }>;
+        }>;
+        confirmUpload(fileId: string): Promise<FileResponse>;
+        getFile(fileId: string): Promise<FileResponse>;
+        getFileUrl(fileId: string, expiresIn?: number): Promise<{
+            url: string;
+            expiresAt: string;
+        }>;
+        deleteFile(fileId: string): Promise<void>;
+        getConversationFiles(conversationId: string, params?: {
+            page?: number;
+            limit?: number;
+            type?: FileType;
+        }): Promise<PaginatedResponse<FileResponse>>;
+        getMyFiles(params?: {
+            page?: number;
+            limit?: number;
+        }): Promise<PaginatedResponse<FileResponse>>;
+    };
+    readonly socket: ClientSocketHandle;
+    constructor(rawConfig: AntzChatConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    uploadFiles(files: UploadableFile[], conversationId?: string): Promise<BatchUploadResult>;
+}
+
+export { AntzChatClient, type AntzChatConfig, type Attachment, type AuthResponse, type AuthTokens, type BatchUploadResult, type Conversation, type CreateDirectData, type CreateGroupData, type CursorPaginatedResponse, type EncryptedContent, type EncryptionKeyInfo, type EncryptionMode, type FileResponse, type FileSizeLimits, type FileType, type ListMessagesParams, type LoginCredentials, type Message, type MessageAckEvent, type MessageContent, type MessageDeletedEvent, type MessageDeliveredEvent, type MessageReaction, type MessageReplyReference, type MessageUpdatedEvent, type MessagesDeliveredEvent, type MobileDeviceToken, type NewMessageEvent, type OptimisticAttachment, type PaginatedResponse, type Participant, type PersistStorage, type PlatformUploadFn, type PresignedUrlRequest, type PresignedUrlResponse, type ReactionUpdatedEvent, type ReadReceiptEvent, type RegisterData, type RegisterDeviceTokenPayload, type ResolvedConfig, type ResolvedFileSizeLimits, type SearchParams, type SendData, type SendMessageAttachment, type SendMessagePayload, type SocketStatus, type StatusListener, type TokenStore, type TypingIndicatorEvent, type UpdateConversationData, type UploadConfig, type UploadProgress, type UploadableFile, type User, type UserStatusEvent, type WebPushDeviceToken, authApi, connectSocket, conversationsApi, createAuthStore, devicesApi, disconnectSocket, getApiClient, getAuthStore, getSocket, getSocketStatus, initApiClient, initAuthStore, messagesApi, normalizeConversation, onSocketStatus, reconnectSocket, resetAuthStore, resolveConfig, setApiClientInstance, socketEmit, storageApi, tryGetSocket, uploadBatch, useChatStore };