@bcc-code/vue-bcc-chat-ui 7.2.3 → 7.2.7

package/dist/App.vue.d.ts

@@ -0,0 +1,4 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const __VLS_export: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/FixtureApp.vue.d.ts

@@ -0,0 +1,4 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const __VLS_export: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/auth.d.ts

@@ -0,0 +1,3 @@
+import { App } from 'vue';
+import { Auth0Plugin } from '@auth0/auth0-vue';
+export default function setupAuth(app: App<Element>): Promise< Auth0Plugin>;

package/dist/chat/accessToken.d.ts

@@ -0,0 +1,11 @@
+export interface StoredCometChatToken {
+    sub: string;
+    token: string;
+}
+export declare function getAccessToken(): string | null;
+export declare function storeAccessToken(token: string | null): void;
+export declare function getAccessTokenSubject(accessToken?: string | null): any;
+export declare function getStoredCometChatToken(): StoredCometChatToken | null;
+export declare function retrieveCcToken(): StoredCometChatToken | null;
+export declare function storeCometChatToken(token: StoredCometChatToken): void;
+export declare function clearCometChatToken(): void;

package/dist/chat/avatar.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeAvatarUrl(value: unknown): string | undefined;
+export declare function proxyImage(imageUrl: string): string;
+export declare function resolveAvatarUrlString(value: unknown): string | undefined;

package/dist/chat/cacheScope.d.ts

@@ -0,0 +1,13 @@
+export declare function getChatCacheScope(): string | null;
+export declare function getChatCacheOwner(): string | null;
+/**
+ * Ensures a cache scope exists for the given owner.  Reuses the current scope
+ * when the owner has not changed; rotates it otherwise.
+ */
+export declare function ensureChatCacheScope(ownerId: string): string;
+/**
+ * Clears the in-memory mirrors so the next read re-fetches from localStorage.
+ * Only needed in tests where localStorage is cleared between runs without
+ * reloading the module.
+ */
+export declare function resetCacheScopeForTesting(): void;

package/dist/chat/client.d.ts

@@ -0,0 +1,7 @@
+import { Environment } from './environment';
+import { ChatClient } from './types';
+interface CreateChatClientOptions {
+    environment: Environment;
+}
+export declare function createChatClient({ environment }: CreateChatClientOptions): ChatClient;
+export {};

package/dist/chat/clipboardFiles.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the first image file from a paste event, with a stable filename when the OS
+ * provides a generic clipboard name (common for screenshots).
+ */
+export declare function getClipboardImageFile(event: ClipboardEvent): File | null;

package/dist/chat/conversationState.d.ts

@@ -0,0 +1,17 @@
+import { ChatConversationItem, MessageSendOptions } from './types';
+export declare function isConversationChannel(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function hasJoinedConversation(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function getConversationScope(conversation?: Pick<ChatConversationItem, "source"> | null): string | undefined;
+export declare function isConversationReadOnly(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function canUseConversationMessageActions(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function canReactInConversation(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function canReplyInConversation(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+/**
+ * Pinning follows who may write. Ordinary chats have no moderators, so every
+ * participant may pin. A channel only lets its moderators post, so only they
+ * may pin there too.
+ */
+export declare function canPinInConversation(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function canOpenThreadInConversation(conversation?: Pick<ChatConversationItem, "source"> | null): boolean;
+export declare function canShowConversationAvatars(conversation?: Pick<ChatConversationItem, "source" | "type"> | null): boolean;
+export declare function getConversationSendOptions(conversation: Pick<ChatConversationItem, "source"> | null | undefined, senderDisplayName?: string): MessageSendOptions | undefined;

package/dist/chat/data.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { getMessageTextPreview } from './messageText';
+import { CachedParticipantSettings, ChatConversationItem, ParticipantInfo, PersonSettings, SearchedItems } from './types';
+export declare function getSenderDisplayName(message: any, group?: Ref<{
+    getMetadata?: () => Record<string, any>;
+} | undefined>): any;
+export { getMessageTextPreview };
+export declare function searchChat(searchQuery: string, limit?: number, currentUserId?: string | null): SearchedItems | undefined;
+export declare function getChatMembersInfo(chatUid: string): Promise<ParticipantInfo[]>;
+export declare function getMutedUntil(chatUid: string): Promise<string | null>;
+export declare function muteChat(chatUid: string, mutedUntil: string | null): Promise<string | null>;
+export declare function getMyChatSettings(): Promise<PersonSettings>;
+export declare function updateMyChatSettings(settings: Partial<PersonSettings>): Promise<PersonSettings>;
+export declare function setMuteAll(mute: boolean): Promise<boolean>;
+export declare function toggleMuteAll(): Promise<boolean>;
+export declare function getCachedParticipantSettings(chatUid: string): CachedParticipantSettings | null;
+export declare function cacheParticipantSettings(settings: CachedParticipantSettings): void;
+export declare function applyMuteSettingToConversations(conversations: ChatConversationItem[], chatUid: string, mutedUntil: string | null): ChatConversationItem[];

package/dist/chat/environment.d.ts

@@ -0,0 +1,8 @@
+export type Environment = "prod" | "sandbox";
+export interface ChatEnvironmentConfig {
+    region: string;
+    appId: string;
+    chatApiBaseUrl: string;
+}
+export declare function setCurrentEnvironment(environment: Environment): void;
+export declare function getCurrentEnvironment(): ChatEnvironmentConfig;

package/dist/chat/i18n/en.d.ts

@@ -0,0 +1,151 @@
+import { TranslationParams } from './types';
+export declare const englishTranslations: {
+    readonly addOption: "Add option";
+    readonly addToMessage: "Add to message";
+    readonly applyLink: "Apply link";
+    readonly attachAudio: "Attach audio";
+    readonly attachFile: "Attach file";
+    readonly attachImage: "Attach image";
+    readonly attachVideo: "Attach video";
+    readonly attachment: "Attachment";
+    readonly attachmentSummary: ({ name }: TranslationParams) => string;
+    readonly audio: "Audio";
+    readonly audioMessage: "Audio message";
+    readonly back: "Back";
+    readonly bold: "Bold";
+    readonly cancel: "Cancel";
+    readonly chatNotFound: "Chat not found...";
+    readonly chatNotAMember: "You are not a member of this chat.";
+    readonly close: "Close";
+    readonly closeMediaViewer: "Close media viewer";
+    readonly closeThread: "Close thread";
+    readonly connecting: "Connecting...";
+    readonly copyText: "Copy text";
+    readonly copied: "Copied";
+    readonly createPoll: "Create poll";
+    readonly createPollTitle: "Create poll";
+    readonly currentDraftWillBeScheduled: "Current draft will be scheduled.";
+    readonly delete: "Delete";
+    readonly delivered: "Delivered";
+    readonly deliveredNotYetRead: "Delivered, not yet read";
+    readonly deliveredToAll: "Delivered to all";
+    readonly deliveryAndReadDetails: "Delivery and read details";
+    readonly downloadVideo: "Download video";
+    readonly edit: "Edit";
+    readonly edited: "edited";
+    readonly editing: "Editing";
+    readonly editingInContext: ({ context }: TranslationParams) => string;
+    readonly failed: "Failed";
+    readonly file: "File";
+    readonly forward: "Forward";
+    readonly forwardedFrom: ({ name }: TranslationParams) => string;
+    readonly forwardedToConversation: ({ title }: TranslationParams) => string;
+    readonly forwardMessage: "Forward message";
+    readonly goToMessage: "Go to message";
+    readonly groupChat: "Group chat";
+    readonly hiddenHelperConversation: "Hidden helper conversation";
+    readonly image: "Image";
+    readonly info: "Info";
+    readonly italic: "Italic";
+    readonly insertLink: "Insert link";
+    readonly invalidLinkUrl: "Enter a valid web URL.";
+    readonly link: "Link";
+    readonly linkUrl: "URL";
+    readonly linkUrlPlaceholder: "https://example.com";
+    readonly loadMessageReceiptsError: "Unable to load message receipts.";
+    readonly loadScheduledMessagesError: "Unable to load scheduled messages.";
+    readonly loadOlderMessages: "Load older messages";
+    readonly loadingOlderMessages: "Loading older messages";
+    readonly loadingChat: "Loading chat...";
+    readonly loadingPreview: "Loading preview...";
+    readonly members: ({ count }: TranslationParams) => string;
+    readonly message: "Message";
+    readonly messageInfo: "Message info";
+    readonly messages: "Messages";
+    readonly multipleAnswersAllowed: "multiple answers allowed";
+    readonly noMatchingChatsFound: "No matching chats found.";
+    readonly noMessagesHaveBeenSentYet: "No messages have been sent yet";
+    readonly noMessagesYetInThisGroup: "No messages yet in this group.";
+    readonly noPinnedMessages: "No pinned messages in this conversation.";
+    readonly noRecipientsDeliveredStageYet: "No one here.";
+    readonly noScheduledMessagesForConversation: "No scheduled messages for this conversation.";
+    readonly nobodyHasReadThisMessageYet: "No one yet.";
+    readonly notYet: "Not yet";
+    readonly offline: "Offline";
+    readonly offlineQueued: ({ count }: TranslationParams) => string;
+    readonly openInNewTab: "Open in new tab";
+    readonly openVideoViewer: "Open video viewer";
+    readonly option: ({ index }: TranslationParams) => string;
+    readonly options: "Options";
+    readonly pause: "Pause";
+    readonly photo: "Photo";
+    readonly pinLimitReached: "This chat has reached its limit of pinned messages. Unpin one to pin another.";
+    readonly pinMessage: "Pin message";
+    readonly pinNotAllowed: "You do not have permission to pin messages here.";
+    readonly pinnedBy: ({ name }: TranslationParams) => string;
+    readonly pinnedLabel: "Pinned";
+    readonly pinnedMessage: "Pinned message";
+    readonly pinnedMessages: "Pinned messages";
+    readonly pinnedMessagesCount: ({ count }: TranslationParams) => string;
+    readonly play: "Play";
+    readonly poll: "Poll";
+    readonly pollPrefix: ({ question }: TranslationParams) => string;
+    readonly pollQuestionPlaceholder: "What should we prioritize next?";
+    readonly question: "Question";
+    readonly queued: "Queued";
+    readonly queuedForConversation: ({ title }: TranslationParams) => string;
+    readonly queuedOutgoingMessagesForThisChat: "Queued outgoing messages for this chat";
+    readonly reactionsCount: ({ count }: TranslationParams) => string;
+    readonly read: "Read";
+    readonly readBy: "Read by";
+    readonly readByAll: "Read by all";
+    readonly readOnlyChannel: "This channel is read-only.";
+    readonly realtimeOn: "Realtime on";
+    readonly recentConversations: "Recent conversations";
+    readonly refreshingMessages: "Refreshing messages";
+    readonly repliesDisabledInChannels: "Replies are disabled in channels.";
+    readonly reply: "Reply";
+    readonly replying: "Replying";
+    readonly replyingInContext: ({ context }: TranslationParams) => string;
+    readonly remove: "Remove";
+    readonly reschedule: "Reschedule";
+    readonly save: "Save";
+    readonly saveMessage: "Save message";
+    readonly schedule: "Schedule";
+    readonly scheduled: "Scheduled";
+    readonly scheduledDateLabel: ({ date }: TranslationParams) => string;
+    readonly scheduledMessages: "Scheduled messages";
+    readonly scheduleMessage: "Schedule message";
+    readonly searchByGroupName: "Search by group name";
+    readonly selectConversationToStart: "Select a conversation to start reading and sending messages.";
+    readonly sendAt: "Send at";
+    readonly sendAttachment: "Send attachment";
+    readonly sendMessage: "Send message";
+    readonly sending: "Sending";
+    readonly sendPoll: "Send poll";
+    readonly sent: "Sent";
+    readonly sentAnAttachment: "Sent an attachment";
+    readonly seekAudio: "Seek in audio";
+    readonly seen: "Seen";
+    readonly seenCount: ({ count }: TranslationParams) => string;
+    readonly signedInToSandbox: "Signed in to BCC Sandbox";
+    readonly someRecipients: "Some recipients";
+    readonly system: "System";
+    readonly thread: "Thread";
+    readonly threadReplies: ({ count }: TranslationParams) => string;
+    readonly today: "Today";
+    readonly yesterday: "Yesterday";
+    readonly threadWithCount: ({ count }: TranslationParams) => string;
+    readonly translate: "Translate";
+    readonly underline: "Underline";
+    readonly unpin: "Unpin";
+    readonly unpinMessage: "Unpin message";
+    readonly unsupportedMessageType: "Unsupported message type";
+    readonly unscheduled: "Unscheduled";
+    readonly video: "Video";
+    readonly voteCount: ({ count }: TranslationParams) => string;
+    readonly waitingForNetwork: "Waiting for network...";
+    readonly writeMessage: "Write a message...";
+    readonly you: "You";
+    readonly youSentAMessage: "You sent a message";
+};

package/dist/chat/i18n/nb.d.ts

@@ -0,0 +1,151 @@
+import { TranslationParams } from './types';
+export declare const norwegianTranslations: {
+    readonly addOption: "Legg til alternativ";
+    readonly addToMessage: "Legg til i melding";
+    readonly applyLink: "Bruk lenke";
+    readonly attachAudio: "Legg ved lyd";
+    readonly attachFile: "Legg ved fil";
+    readonly attachImage: "Legg ved bilde";
+    readonly attachVideo: "Legg ved video";
+    readonly attachment: "Vedlegg";
+    readonly attachmentSummary: ({ name }: TranslationParams) => string;
+    readonly audio: "Lyd";
+    readonly audioMessage: "Lydmelding";
+    readonly back: "Tilbake";
+    readonly bold: "Fet";
+    readonly cancel: "Avbryt";
+    readonly chatNotFound: "Fant ikke chatten...";
+    readonly chatNotAMember: "Du er ikke medlem av denne chatten.";
+    readonly close: "Lukk";
+    readonly closeMediaViewer: "Lukk medievisning";
+    readonly closeThread: "Lukk tråd";
+    readonly connecting: "Kobler til...";
+    readonly copyText: "Kopier tekst";
+    readonly copied: "Kopiert";
+    readonly createPoll: "Opprett avstemning";
+    readonly createPollTitle: "Opprett avstemning";
+    readonly currentDraftWillBeScheduled: "Gjeldende utkast blir planlagt.";
+    readonly delete: "Slett";
+    readonly delivered: "Levert";
+    readonly deliveredNotYetRead: "Levert, ikke lest ennå";
+    readonly deliveredToAll: "Levert til alle";
+    readonly deliveryAndReadDetails: "Leverings- og lesedetaljer";
+    readonly downloadVideo: "Last ned video";
+    readonly edit: "Rediger";
+    readonly edited: "redigert";
+    readonly editing: "Redigerer";
+    readonly editingInContext: ({ context }: TranslationParams) => string;
+    readonly failed: "Mislyktes";
+    readonly file: "Fil";
+    readonly forward: "Videresend";
+    readonly forwardedFrom: ({ name }: TranslationParams) => string;
+    readonly forwardedToConversation: ({ title }: TranslationParams) => string;
+    readonly forwardMessage: "Videresend melding";
+    readonly goToMessage: "Gå til melding";
+    readonly groupChat: "Gruppechat";
+    readonly hiddenHelperConversation: "Skjult hjelpesamtale";
+    readonly image: "Bilde";
+    readonly info: "Info";
+    readonly italic: "Kursiv";
+    readonly insertLink: "Sett inn lenke";
+    readonly invalidLinkUrl: "Skriv inn en gyldig nettadresse.";
+    readonly link: "Lenke";
+    readonly linkUrl: "URL";
+    readonly linkUrlPlaceholder: "https://eksempel.no";
+    readonly loadMessageReceiptsError: "Kunne ikke laste meldingskvitteringer.";
+    readonly loadScheduledMessagesError: "Kunne ikke laste planlagte meldinger.";
+    readonly loadOlderMessages: "Last eldre meldinger";
+    readonly loadingOlderMessages: "Laster eldre meldinger";
+    readonly loadingChat: "Laster chat...";
+    readonly loadingPreview: "Laster forhåndsvisning...";
+    readonly members: ({ count }: TranslationParams) => string;
+    readonly message: "Melding";
+    readonly messageInfo: "Meldingsinfo";
+    readonly messages: "Meldinger";
+    readonly multipleAnswersAllowed: "flere svar tillatt";
+    readonly noMatchingChatsFound: "Fant ingen samsvarende chatter.";
+    readonly noMessagesHaveBeenSentYet: "Ingen meldinger har blitt sendt ennå";
+    readonly noMessagesYetInThisGroup: "Ingen meldinger i denne gruppen ennå.";
+    readonly noPinnedMessages: "Ingen festede meldinger i denne samtalen.";
+    readonly noRecipientsDeliveredStageYet: "Ingen mottakere er bare på levert-stadiet ennå.";
+    readonly noScheduledMessagesForConversation: "Ingen planlagte meldinger for denne samtalen.";
+    readonly nobodyHasReadThisMessageYet: "Ingen ennå.";
+    readonly notYet: "Ikke ennå";
+    readonly offline: "Frakoblet";
+    readonly offlineQueued: ({ count }: TranslationParams) => string;
+    readonly openInNewTab: "Åpne i ny fane";
+    readonly openVideoViewer: "Åpne videovisning";
+    readonly option: ({ index }: TranslationParams) => string;
+    readonly options: "Alternativer";
+    readonly pause: "Pause";
+    readonly photo: "Bilde";
+    readonly pinLimitReached: "Denne chatten har nådd grensen for festede meldinger. Løsne en for å feste en ny.";
+    readonly pinMessage: "Fest melding";
+    readonly pinNotAllowed: "Du har ikke tillatelse til å feste meldinger her.";
+    readonly pinnedBy: ({ name }: TranslationParams) => string;
+    readonly pinnedLabel: "Festet";
+    readonly pinnedMessage: "Festet melding";
+    readonly pinnedMessages: "Festede meldinger";
+    readonly pinnedMessagesCount: ({ count }: TranslationParams) => string;
+    readonly play: "Spill av";
+    readonly poll: "Avstemning";
+    readonly pollPrefix: ({ question }: TranslationParams) => string;
+    readonly pollQuestionPlaceholder: "Hva bør vi prioritere videre?";
+    readonly question: "Spørsmål";
+    readonly queued: "I kø";
+    readonly queuedForConversation: ({ title }: TranslationParams) => string;
+    readonly queuedOutgoingMessagesForThisChat: "Utgående meldinger i kø for denne chatten";
+    readonly reactionsCount: ({ count }: TranslationParams) => string;
+    readonly read: "Lest";
+    readonly readBy: "Lest av";
+    readonly readByAll: "Lest av alle";
+    readonly readOnlyChannel: "Denne kanalen er skrivebeskyttet.";
+    readonly realtimeOn: "Sanntid på";
+    readonly recentConversations: "Nylige samtaler";
+    readonly refreshingMessages: "Oppdaterer meldinger";
+    readonly repliesDisabledInChannels: "Svar er deaktivert i kanaler.";
+    readonly reply: "Svar";
+    readonly replying: "Svarer";
+    readonly replyingInContext: ({ context }: TranslationParams) => string;
+    readonly remove: "Fjern";
+    readonly reschedule: "Planlegg på nytt";
+    readonly save: "Lagre";
+    readonly saveMessage: "Lagre melding";
+    readonly schedule: "Planlegg";
+    readonly scheduled: "Planlagt";
+    readonly scheduledDateLabel: ({ date }: TranslationParams) => string;
+    readonly scheduledMessages: "Planlagte meldinger";
+    readonly scheduleMessage: "Planlegg melding";
+    readonly searchByGroupName: "Søk etter gruppenavn";
+    readonly selectConversationToStart: "Velg en samtale for å begynne å lese og sende meldinger.";
+    readonly sendAt: "Send kl.";
+    readonly sendAttachment: "Send vedlegg";
+    readonly sendMessage: "Send melding";
+    readonly sending: "Sender";
+    readonly sendPoll: "Send avstemning";
+    readonly sent: "Sendt";
+    readonly sentAnAttachment: "Sendte et vedlegg";
+    readonly seekAudio: "Spol i lyden";
+    readonly seen: "Sett";
+    readonly seenCount: ({ count }: TranslationParams) => string;
+    readonly signedInToSandbox: "Logget inn i BCC Sandbox";
+    readonly someRecipients: "Noen mottakere";
+    readonly system: "System";
+    readonly thread: "Tråd";
+    readonly threadReplies: ({ count }: TranslationParams) => string;
+    readonly today: "I dag";
+    readonly yesterday: "I går";
+    readonly threadWithCount: ({ count }: TranslationParams) => string;
+    readonly translate: "Oversett";
+    readonly underline: "Understrek";
+    readonly unpin: "Løsne";
+    readonly unpinMessage: "Løsne melding";
+    readonly unsupportedMessageType: "Meldingstype støttes ikke";
+    readonly unscheduled: "Ikke planlagt";
+    readonly video: "Video";
+    readonly voteCount: ({ count }: TranslationParams) => string;
+    readonly waitingForNetwork: "Venter på nettverk...";
+    readonly writeMessage: "Skriv en melding...";
+    readonly you: "Du";
+    readonly youSentAMessage: "Du sendte en melding";
+};

package/dist/chat/i18n/types.d.ts

@@ -0,0 +1,2 @@
+export type TranslationParams = Record<string, string | number | undefined>;
+export type TranslationEntry = string | ((params: TranslationParams) => string);

package/dist/chat/index.d.ts

@@ -0,0 +1,240 @@
+import { Group, User, Call } from '@cometchat/chat-sdk-javascript';
+import { App, Ref, ComputedRef, WritableComputedRef } from 'vue';
+import { retrieveCcToken } from './accessToken';
+import { proxyImage } from './avatar';
+import { getChatMembersInfo, getMyChatSettings, getSenderDisplayName, setMuteAll, toggleMuteAll, updateMyChatSettings } from './data';
+import { getCurrentEnvironment, Environment } from './environment';
+import { getMessageTextPreview } from './messageText';
+import { toMarkdownHtml } from './richText';
+import { chatClient } from './runtime';
+import { ChatInstallOptions, ChatMessagesGetter, Language, ChatMessageItem, OnlineStatus, ThemeMode, UserChatInfo, SearchedItems } from './types';
+declare function install(app: App, options: ChatInstallOptions): Promise<void>;
+declare function login(accessToken?: string): Promise<void>;
+declare function logout(): Promise<void>;
+declare function connect(connectionName?: string): Promise<void>;
+declare function disconnect(connectionName?: string): Promise<void>;
+declare function disconnectAll(): Promise<void>;
+declare function setGetChatMessagesCallback(chatMessageGetter: ChatMessagesGetter | undefined): void;
+declare function setLanguage(language: Language): void;
+declare function setThemeMode(mode: ThemeMode): void;
+declare function setAccessToken(token: string): Promise<void>;
+declare function setEnvironment(environment: Environment): void;
+declare function getGroup(groupUid: string, throwErrors?: boolean): Promise<Group | null | undefined>;
+declare function getUserChats(): Promise<{
+    chatUid: string;
+    name: string;
+    unreadMessageCount: number;
+    lastMessage?: {
+        text?: string | undefined;
+        type: string;
+        senderUid: string;
+        senderName: string;
+        sentAt: Date;
+        sentByCurrentUser: boolean;
+        readAt: Date | undefined;
+        messageReceipts?: {
+            RECEIPT_TYPE: {
+                READ_RECEIPT: string;
+                DELIVERY_RECEIPT: string;
+                READ_BY_ALL_RECEIPT: string;
+                DELIVERED_TO_ALL_RECEIPT: string;
+            };
+            getReceiverType: () => string;
+            setReceiverType: (receiverType: string) => void;
+            getSender: () => User;
+            setSender: (sender: User) => void;
+            getReceiver: () => string;
+            setReceiver: (receiver: string) => void;
+            getTimestamp: () => string;
+            setTimestamp: (timestamp: string) => void;
+            setReadAt: (readAt: number) => void;
+            getReadAt: () => number;
+            setDeliveredAt: (deliveredAt: number) => void;
+            getDeliveredAt: () => number;
+            getMessageId: () => string;
+            setMessageId: (messageId: string) => void;
+            getReceiptType: () => string;
+            setReceiptType: (receiptType?: string) => void;
+        }[] | undefined;
+    } | undefined;
+    membersCount: number;
+    tags: string[];
+    muteSettings?: (Date | null) | undefined;
+    hasJoined: boolean;
+}[]>;
+declare function clearChatCount(chatUid: string): Promise<void>;
+declare function getChatOnlineCount(chatUid: string): Promise<number>;
+declare function muteChat(chatUid: string, mutedUntil: string | null): Promise<string | null>;
+declare function getMutedUntil(chatUid: string): Promise<string | null>;
+declare function pinMessage(message: ChatMessageItem): Promise<void>;
+declare function unpinMessage(messageId: string): Promise<void>;
+declare function togglePinnedMessage(message: ChatMessageItem): Promise<void>;
+declare function isMessagePinned(messageId: string): boolean;
+declare function scrollToMessage(messageId: string): void;
+export { chatClient };
+declare const chat: {
+    install: typeof install;
+    setGetChatMessagesCallback: typeof setGetChatMessagesCallback;
+    initialized: Ref<boolean, boolean>;
+    connected: ComputedRef<boolean>;
+    connecting: ComputedRef<boolean>;
+    loggedIn: ComputedRef<boolean>;
+    userChats: Ref<{
+        chatUid: string;
+        name: string;
+        unreadMessageCount: number;
+        lastMessage?: {
+            text?: string | undefined;
+            type: string;
+            senderUid: string;
+            senderName: string;
+            sentAt: Date;
+            sentByCurrentUser: boolean;
+            readAt: Date | undefined;
+            messageReceipts?: {
+                RECEIPT_TYPE: {
+                    READ_RECEIPT: string;
+                    DELIVERY_RECEIPT: string;
+                    READ_BY_ALL_RECEIPT: string;
+                    DELIVERED_TO_ALL_RECEIPT: string;
+                };
+                getReceiverType: () => string;
+                setReceiverType: (receiverType: string) => void;
+                getSender: () => User;
+                setSender: (sender: User) => void;
+                getReceiver: () => string;
+                setReceiver: (receiver: string) => void;
+                getTimestamp: () => string;
+                setTimestamp: (timestamp: string) => void;
+                setReadAt: (readAt: number) => void;
+                getReadAt: () => number;
+                setDeliveredAt: (deliveredAt: number) => void;
+                getDeliveredAt: () => number;
+                getMessageId: () => string;
+                setMessageId: (messageId: string) => void;
+                getReceiptType: () => string;
+                setReceiptType: (receiptType?: string) => void;
+            }[] | undefined;
+        } | undefined;
+        membersCount: number;
+        tags: string[];
+        muteSettings?: (Date | null) | undefined;
+        hasJoined: boolean;
+    }[], UserChatInfo[] | {
+        chatUid: string;
+        name: string;
+        unreadMessageCount: number;
+        lastMessage?: {
+            text?: string | undefined;
+            type: string;
+            senderUid: string;
+            senderName: string;
+            sentAt: Date;
+            sentByCurrentUser: boolean;
+            readAt: Date | undefined;
+            messageReceipts?: {
+                RECEIPT_TYPE: {
+                    READ_RECEIPT: string;
+                    DELIVERY_RECEIPT: string;
+                    READ_BY_ALL_RECEIPT: string;
+                    DELIVERED_TO_ALL_RECEIPT: string;
+                };
+                getReceiverType: () => string;
+                setReceiverType: (receiverType: string) => void;
+                getSender: () => User;
+                setSender: (sender: User) => void;
+                getReceiver: () => string;
+                setReceiver: (receiver: string) => void;
+                getTimestamp: () => string;
+                setTimestamp: (timestamp: string) => void;
+                setReadAt: (readAt: number) => void;
+                getReadAt: () => number;
+                setDeliveredAt: (deliveredAt: number) => void;
+                getDeliveredAt: () => number;
+                getMessageId: () => string;
+                setMessageId: (messageId: string) => void;
+                getReceiptType: () => string;
+                setReceiptType: (receiptType?: string) => void;
+            }[] | undefined;
+        } | undefined;
+        membersCount: number;
+        tags: string[];
+        muteSettings?: (Date | null) | undefined;
+        hasJoined: boolean;
+    }[]>;
+    userUid: ComputedRef<string | undefined>;
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    disconnectAll: typeof disconnectAll;
+    setAccessToken: typeof setAccessToken;
+    login: typeof login;
+    logout: typeof logout;
+    setCurrentEnvironment: typeof setEnvironment;
+    getCurrentEnvironment: typeof getCurrentEnvironment;
+    setThemeMode: typeof setThemeMode;
+    setLanguage: typeof setLanguage;
+    getGroup: typeof getGroup;
+    getChatMembersInfo: typeof getChatMembersInfo;
+    getUserChats: typeof getUserChats;
+    clearChatCount: typeof clearChatCount;
+    refreshVisibleMessages: () => Promise<void> | undefined;
+    getChatOnlineCount: typeof getChatOnlineCount;
+    searchChat: (searchQuery: string, limit?: number) => SearchedItems | undefined;
+    getSenderDisplayName: typeof getSenderDisplayName;
+    getMessageTextPreview: typeof getMessageTextPreview;
+    proxyImage: typeof proxyImage;
+    getMutedUntil: typeof getMutedUntil;
+    muteChat: typeof muteChat;
+    getMyChatSettings: typeof getMyChatSettings;
+    updateMyChatSettings: typeof updateMyChatSettings;
+    setMuteAll: typeof setMuteAll;
+    toggleMuteAll: typeof toggleMuteAll;
+    toMarkdownHtml: typeof toMarkdownHtml;
+    retrieveCcToken: typeof retrieveCcToken;
+    getChatMessages: Ref<ChatMessagesGetter | undefined, ChatMessagesGetter | undefined>;
+    scrollToMessageId: Ref<string | undefined, string | undefined>;
+    scrollToMessage: typeof scrollToMessage;
+    pinnedMessages: ComputedRef<ChatMessageItem[]>;
+    pinMessage: typeof pinMessage;
+    unpinMessage: typeof unpinMessage;
+    togglePinnedMessage: typeof togglePinnedMessage;
+    isMessagePinned: typeof isMessagePinned;
+    connectivity: {
+        onlineMode: WritableComputedRef<OnlineStatus, OnlineStatus>;
+        onlineStatus: ComputedRef<OnlineStatus>;
+    };
+    onlineMode: WritableComputedRef<OnlineStatus, OnlineStatus>;
+    onlineStatus: ComputedRef<OnlineStatus>;
+    theme: Ref<{
+        palette: {
+            mode: ThemeMode;
+            setMode: (mode: ThemeMode) => void;
+        };
+    }, {
+        palette: {
+            mode: ThemeMode;
+            setMode(mode: ThemeMode): void;
+        };
+    } | {
+        palette: {
+            mode: ThemeMode;
+            setMode: (mode: ThemeMode) => void;
+        };
+    }>;
+    themeMode: Ref<ThemeMode, ThemeMode>;
+    language: Ref<Language, Language>;
+    calls: {
+        state: ComputedRef<"idle" | "outgoing" | "incoming" | "connecting" | "in-call">;
+        activeType: ComputedRef<"video" | "audio">;
+        activeSessionId: ComputedRef<string | null>;
+        incomingCall: ComputedRef< Call | null>;
+        incomingCalls: ComputedRef<Map<string, Call>>;
+        outgoingCall: ComputedRef< Call | null>;
+        start: (receiverId: string, container: HTMLElement, callType?: "audio" | "video", receiverType?: "user" | "group") => Promise< Call>;
+        accept: (container: HTMLElement, sessionId?: string) => Promise<void>;
+        reject: (sessionId?: string) => Promise<void>;
+        end: () => Promise<void>;
+        joinActive: (container: HTMLElement) => Promise<void>;
+    };
+};
+export default chat;