@wireapp/core 31.1.3 → 31.1.4

package/src/main/connection/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ConnectionService"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/conversation/AbortReason.d.ts

@@ -0,0 +1,2 @@
+import { Asset } from '@wireapp/protocol-messaging';
+export declare type AbortReason = Asset.NotUploaded;

package/src/main/conversation/AbortReason.js

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AbortReason.js.map

package/src/main/conversation/AssetService/AssetService.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { APIClient } from '@wireapp/api-client';
+import { AssetOptions } from '@wireapp/api-client/src/asset';
+import { ProgressCallback, RequestCancelable } from '@wireapp/api-client/src/http';
+import { EncryptedAssetUploaded } from '../../cryptography';
+export interface AssetDataV4 {
+    assetKey: string;
+    assetToken: string;
+    assetDomain: string;
+    forceCaching: boolean;
+    version: 4;
+}
+export interface AssetDataV3 {
+    assetKey: string;
+    assetToken: string;
+    forceCaching: boolean;
+    version: 3;
+}
+export interface AssetDataV2 {
+    assetId: string;
+    conversationId: string;
+    forceCaching: boolean;
+    version: 2;
+}
+export interface AssetDataV1 {
+    assetId: string;
+    conversationId: string;
+    forceCaching: boolean;
+    version: 1;
+}
+export declare type AssetUrlData = AssetDataV1 | AssetDataV2 | AssetDataV3 | AssetDataV4;
+export declare class AssetService {
+    private readonly apiClient;
+    constructor(apiClient: APIClient);
+    /**
+     * Will download an asset on the server.
+     * Will route the request to the right endpoint depending on the asset version
+     *
+     * @param assetData The versioned asset data
+     * @param progressCallback?
+     * @return Resolves when the asset has been uploaded
+     */
+    downloadAsset(assetData: AssetUrlData, progressCallback?: ProgressCallback): RequestCancelable<import("@wireapp/api-client/src/asset").AssetResponse>;
+    /**
+     * Uploads a raw asset to the backend without encrypting it
+     *
+     * @param plainText The raw content of the asset to upload
+     * @param options?
+     * @param progressCallback?
+     * @return cancellable request that resolves with the uploaded image
+     */
+    uploadRawAsset(asset: Buffer | Uint8Array, options?: AssetOptions, progressCallback?: ProgressCallback): RequestCancelable<import("@wireapp/api-client/src/asset").AssetUploadData>;
+    /**
+     * Will encrypt and upload an asset to the backend
+     *
+     * @param plainText The raw content of the asset to upload
+     * @param options?
+     * @param progressCallback?
+     * @return cancellable request that resolves with the uploaded image and decryption keys
+     */
+    uploadAsset(plainText: Buffer | Uint8Array, options?: AssetOptions, progressCallback?: ProgressCallback): Promise<RequestCancelable<EncryptedAssetUploaded>>;
+}

package/src/main/conversation/AssetService/AssetService.js

@@ -0,0 +1,88 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetService = void 0;
+const AssetCryptography_1 = require("../../cryptography/AssetCryptography");
+class AssetService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Will download an asset on the server.
+     * Will route the request to the right endpoint depending on the asset version
+     *
+     * @param assetData The versioned asset data
+     * @param progressCallback?
+     * @return Resolves when the asset has been uploaded
+     */
+    downloadAsset(assetData, progressCallback) {
+        const { forceCaching } = assetData;
+        switch (assetData.version) {
+            case 1:
+                return this.apiClient.api.asset.getAssetV1(assetData.assetId, assetData.conversationId, forceCaching, progressCallback);
+            case 2:
+                return this.apiClient.api.asset.getAssetV2(assetData.assetId, assetData.conversationId, forceCaching, progressCallback);
+            case 3:
+                return this.apiClient.api.asset.getAssetV3(assetData.assetKey, assetData.assetToken, forceCaching, progressCallback);
+            case 4:
+                return this.apiClient.api.asset.getAssetV4(assetData.assetKey, assetData.assetDomain, assetData.assetToken, forceCaching, progressCallback);
+        }
+    }
+    /**
+     * Uploads a raw asset to the backend without encrypting it
+     *
+     * @param plainText The raw content of the asset to upload
+     * @param options?
+     * @param progressCallback?
+     * @return cancellable request that resolves with the uploaded image
+     */
+    uploadRawAsset(asset, options, progressCallback) {
+        return this.apiClient.api.asset.postAsset(new Uint8Array(asset), options, progressCallback);
+    }
+    /**
+     * Will encrypt and upload an asset to the backend
+     *
+     * @param plainText The raw content of the asset to upload
+     * @param options?
+     * @param progressCallback?
+     * @return cancellable request that resolves with the uploaded image and decryption keys
+     */
+    async uploadAsset(plainText, options, progressCallback) {
+        const { cipherText, keyBytes, sha256 } = await (0, AssetCryptography_1.encryptAsset)({
+            plainText,
+            algorithm: options === null || options === void 0 ? void 0 : options.algorithm,
+            hash: options === null || options === void 0 ? void 0 : options.hash,
+        });
+        const request = this.uploadRawAsset(cipherText, options, progressCallback);
+        return Object.assign(Object.assign({}, request), { response: request.response.then(response => {
+                const { key, token, domain } = response;
+                return {
+                    cipherText,
+                    domain,
+                    key,
+                    keyBytes,
+                    sha256,
+                    token,
+                };
+            }) });
+    }
+}
+exports.AssetService = AssetService;
+//# sourceMappingURL=AssetService.js.map

package/src/main/conversation/AssetService/index.d.ts

@@ -0,0 +1 @@
+export * from './AssetService';

package/src/main/conversation/AssetService/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2022 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AssetService"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/conversation/AssetTransferState.d.ts

@@ -0,0 +1,4 @@
+export declare enum AssetTransferState {
+    NOT_UPLOADED = "notUploaded",
+    UPLOADED = "uploaded"
+}

package/src/main/conversation/AssetTransferState.js

@@ -0,0 +1,27 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetTransferState = void 0;
+var AssetTransferState;
+(function (AssetTransferState) {
+    AssetTransferState["NOT_UPLOADED"] = "notUploaded";
+    AssetTransferState["UPLOADED"] = "uploaded";
+})(AssetTransferState = exports.AssetTransferState || (exports.AssetTransferState = {}));
+//# sourceMappingURL=AssetTransferState.js.map

package/src/main/conversation/ClientActionType.d.ts

@@ -0,0 +1 @@
+export { ClientAction as ClientActionType } from '@wireapp/protocol-messaging';

package/src/main/conversation/ClientActionType.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientActionType = void 0;
+var protocol_messaging_1 = require("@wireapp/protocol-messaging");
+Object.defineProperty(exports, "ClientActionType", { enumerable: true, get: function () { return protocol_messaging_1.ClientAction; } });
+//# sourceMappingURL=ClientActionType.js.map

package/src/main/conversation/ConversationMapper/ConversationMapper.d.ts

@@ -0,0 +1,6 @@
+import { ConversationEvent } from '@wireapp/api-client/src/event';
+import { PayloadBundle, PayloadBundleSource } from '../message/PayloadBundle';
+export declare class ConversationMapper {
+    static mapConversationEvent(event: ConversationEvent, source: PayloadBundleSource): PayloadBundle;
+    private static mapConversationEventType;
+}

package/src/main/conversation/ConversationMapper/ConversationMapper.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2019 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationMapper = void 0;
+const event_1 = require("@wireapp/api-client/src/event");
+const MessageBuilder_1 = require("../message/MessageBuilder");
+const PayloadBundle_1 = require("../message/PayloadBundle");
+class ConversationMapper {
+    static mapConversationEvent(event, source) {
+        return {
+            content: event.data,
+            conversation: event.conversation,
+            qualifiedConversation: event.qualified_conversation,
+            qualifiedFrom: event.qualified_from,
+            from: event.from,
+            id: MessageBuilder_1.MessageBuilder.createId(),
+            messageTimer: 0,
+            source,
+            state: PayloadBundle_1.PayloadBundleState.INCOMING,
+            timestamp: new Date(event.time).getTime(),
+            type: this.mapConversationEventType(event.type),
+        };
+    }
+    static mapConversationEventType(type) {
+        switch (type) {
+            case event_1.CONVERSATION_EVENT.MEMBER_JOIN:
+                return PayloadBundle_1.PayloadBundleType.MEMBER_JOIN;
+            case event_1.CONVERSATION_EVENT.MESSAGE_TIMER_UPDATE:
+                return PayloadBundle_1.PayloadBundleType.TIMER_UPDATE;
+            case event_1.CONVERSATION_EVENT.RENAME:
+                return PayloadBundle_1.PayloadBundleType.CONVERSATION_RENAME;
+            case event_1.CONVERSATION_EVENT.TYPING:
+                return PayloadBundle_1.PayloadBundleType.TYPING;
+            default:
+                return PayloadBundle_1.PayloadBundleType.UNKNOWN;
+        }
+    }
+}
+exports.ConversationMapper = ConversationMapper;
+//# sourceMappingURL=ConversationMapper.js.map

package/src/main/conversation/ConversationMapper/index.d.ts

@@ -0,0 +1 @@
+export * from './ConversationMapper';

package/src/main/conversation/ConversationMapper/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2022 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ConversationMapper"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/conversation/ConversationService/ConversationService.d.ts

@@ -0,0 +1,149 @@
+import { APIClient } from '@wireapp/api-client';
+import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedStatus, NewConversation, QualifiedUserClients, UserClients, ClientMismatch } from '@wireapp/api-client/src/conversation';
+import { ConversationMemberLeaveEvent } from '@wireapp/api-client/src/event';
+import { QualifiedId, UserPreKeyBundleMap } from '@wireapp/api-client/src/user';
+import { MessageTimer, RemoveUsersParams } from '../../conversation/';
+import { RemoteData } from '../content';
+import { CryptographyService } from '../../cryptography/';
+import { MLSService } from '../../mls';
+import { NotificationService } from '../../notification';
+import { ClearConversationMessage, OtrMessage } from '../message/OtrMessage';
+import { XOR } from '@wireapp/commons/src/main/util/TypeUtil';
+import { AddUsersParams, MessageSendingOptions, MLSReturnType, SendMlsMessageParams, SendProteusMessageParams } from './ConversationService.types';
+export declare class ConversationService {
+    private readonly apiClient;
+    private readonly config;
+    private readonly notificationService;
+    private readonly mlsService;
+    readonly messageTimer: MessageTimer;
+    private readonly messageService;
+    private selfConversationId?;
+    constructor(apiClient: APIClient, cryptographyService: CryptographyService, config: {
+        useQualifiedIds?: boolean;
+    }, notificationService: NotificationService, mlsService: MLSService);
+    private getConversationQualifiedMembers;
+    /**
+     * Will generate a prekey bundle for specific users.
+     * If a QualifiedId array is given the bundle will contain all the clients from those users fetched from the server.
+     * If a QualifiedUserClients is provided then only the clients in the payload will be targeted (which could generate a ClientMismatch when sending messages)
+     *
+     * @param {QualifiedId[]|QualifiedUserClients} userIds - Targeted users.
+     * @returns {Promise<QualifiedUserPreKeyBundleMap}
+     */
+    private getQualifiedPreKeyBundle;
+    getPreKeyBundleMap(conversationId: string, userIds?: string[] | UserClients): Promise<UserPreKeyBundleMap>;
+    private getSelfConversationId;
+    private getQualifiedRecipientsForConversation;
+    private getRecipientsForConversation;
+    /**
+     * Sends a message to a conversation
+     *
+     * @param sendingClientId The clientId from which the message is sent
+     * @param conversationId The conversation in which to send the message
+     * @param genericMessage The payload of the message to send
+     * @return Resolves with the message sending status from backend
+     */
+    private sendGenericMessage;
+    private extractUserIds;
+    private extractQualifiedUserIds;
+    clearConversation(conversationId: string, timestamp?: number | Date, messageId?: string, sendAsProtobuf?: boolean): Promise<ClearConversationMessage>;
+    /**
+     * Sends a LastRead message to the current user's self conversation.
+     * This will allow all the user's devices to compute which messages are unread
+     *
+     * @param conversationId The conversation which has been read
+     * @param lastReadTimestamp The timestamp at which the conversation was read
+     * @param sendingOptions?
+     * @return Resolves when the message has been sent
+     */
+    sendLastRead(conversationId: string, lastReadTimestamp: number, sendingOptions?: MessageSendingOptions): Promise<(MessageSendingStatus & {
+        errored?: boolean | undefined;
+    }) | (ClientMismatch & {
+        errored?: boolean | undefined;
+    })>;
+    /**
+     * Syncs all self user's devices with the countly id
+     *
+     * @param countlyId The countly id of the current device
+     * @param sendingOptions?
+     * @return Resolves when the message has been sent
+     */
+    sendCountlySync(countlyId: string, sendingOptions: MessageSendingOptions): Promise<(MessageSendingStatus & {
+        errored?: boolean | undefined;
+    }) | (ClientMismatch & {
+        errored?: boolean | undefined;
+    })>;
+    /**
+     * Get a fresh list from backend of clients for all the participants of the conversation.
+     * This is a hacky way of getting all the clients for a conversation.
+     * The idea is to send an empty message to the backend to absolutely no users and let backend reply with a mismatch error.
+     * We then get the missing members in the mismatch, that is our fresh list of participants' clients.
+     *
+     * @deprecated
+     * @param {string} conversationId
+     * @param {string} conversationDomain? - If given will send the message to the new qualified endpoint
+     */
+    getAllParticipantsClients(conversationId: string, conversationDomain?: string): Promise<UserClients | QualifiedUserClients>;
+    /**
+     * Get a fresh list from backend of clients for all the participants of the conversation.
+     * @fixme there are some case where this method is not enough to detect removed devices
+     * @param {string} conversationId
+     * @param {string} conversationDomain? - If given will send the message to the new qualified endpoint
+     */
+    fetchAllParticipantsClients(conversationId: string, conversationDomain?: string): Promise<UserClients | QualifiedUserClients>;
+    /**
+     * Create a group conversation.
+     * @param  {string} name
+     * @param  {string|string[]} otherUserIds
+     * @deprecated
+     * @returns Promise
+     */
+    createProteusConversation(name: string, otherUserIds: string | string[]): Promise<Conversation>;
+    /**
+     * Create a group conversation.
+     *
+     * @note Do not include yourself as the requestor
+     * @see https://staging-nginz-https.zinfra.io/swagger-ui/#!/conversations/createGroupConversation
+     *
+     * @param conversationData Payload object for group creation
+     * @returns Resolves when the conversation was created
+     */
+    createProteusConversation(conversationData: NewConversation): Promise<Conversation>;
+    getConversations(conversationId: string): Promise<Conversation>;
+    getConversations(conversationIds?: string[]): Promise<Conversation[]>;
+    getAsset({ assetId, assetToken, otrKey, sha256 }: RemoteData): Promise<Uint8Array>;
+    getUnencryptedAsset(assetId: string, assetToken?: string): Promise<ArrayBuffer>;
+    addUsersToProteusConversation({ conversationId, qualifiedUserIds }: Omit<AddUsersParams, 'groupId'>): Promise<import("@wireapp/api-client/src/event").ConversationMemberJoinEvent>;
+    removeUserFromConversation(conversationId: QualifiedId, userId: QualifiedId): Promise<ConversationMemberLeaveEvent>;
+    private sendProteusMessage;
+    /**
+     * Sends a message to a conversation
+     * @return resolves with the sent message
+     */
+    send<T extends OtrMessage>(params: XOR<SendMlsMessageParams<T>, SendProteusMessageParams<T>>): Promise<T>;
+    sendTypingStart(conversationId: string): Promise<void>;
+    sendTypingStop(conversationId: string): Promise<void>;
+    setConversationMutedStatus(conversationId: string, status: MutedStatus, muteTimestamp: number | Date): Promise<void>;
+    toggleArchiveConversation(conversationId: string, archived: boolean, archiveTimestamp?: number | Date): Promise<void>;
+    setMemberConversationRole(conversationId: string, userId: string, conversationRole: DefaultConversationRoleName | string): Promise<void>;
+    private isClearFromMismatch;
+    /**
+     *   ###############################################
+     *   ################ MLS Functions ################
+     *   ###############################################
+     */
+    createMLSConversation(conversationData: NewConversation): Promise<MLSReturnType>;
+    private sendMLSMessage;
+    addUsersToMLSConversation({ qualifiedUserIds, groupId, conversationId, }: Required<AddUsersParams>): Promise<MLSReturnType>;
+    private storeLastKeyMaterialUpdateDateWithCurrentTime;
+    removeUsersFromMLSConversation({ groupId, conversationId, qualifiedUserIds, }: RemoveUsersParams): Promise<MLSReturnType>;
+    /**
+     * Will send an external proposal for the current device to join a specific conversation.
+     * In order for the external proposal to be sent correctly, the underlying mls conversation needs to be in a non-established state
+     * @param conversationGroupId The conversation to join
+     * @param epoch The current epoch of the local conversation
+     */
+    sendExternalJoinProposal(conversationGroupId: string, epoch: number): Promise<void>;
+    isMLSConversationEstablished(conversationGroupId: string): Promise<boolean>;
+    wipeMLSConversation(conversationId: Uint8Array): Promise<void>;
+}