@wireapp/core 32.0.4 → 32.0.6

package/package.json

@@ -65,7 +65,7 @@
     "!src/main/**/*test*.ts"
   ],
   "license": "GPL-3.0",
-  "main": "src/main/Account",
+  "main": "src/main/index",
   "name": "@wireapp/core",
   "repository": "https://github.com/wireapp/wire-web-packages/tree/main/packages/core",
   "scripts": {
@@ -81,6 +81,6 @@
     "test": "jest",
     "watch": "tsc ---watch"
   },
-  "version": "32.0.4",
-  "gitHead": "98e4487ae72c0bfd8a3633bad937723b05d155c8"
+  "version": "32.0.6",
+  "gitHead": "b7e78c5c3923cd10386056cdeff94c74a56030a2"
 }

package/src/main/Account.js

@@ -442,6 +442,7 @@ class Account extends events_1.EventEmitter {
             this.apiClient.transport.ws.unlock();
             // We need to wait for the notification stream to be fully handled before releasing the message sending queue.
             // This is due to the nature of how message are encrypted, any change in mls epoch needs to happen before we start encrypting any kind of messages
+            this.logger.log(`resume message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
             (0, messageSender_1.resumeMessageSending)();
             onConnectionStateChanged(ConnectionState.LIVE);
         };

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

@@ -30,7 +30,7 @@ class ConversationMapper {
             qualifiedConversation: event.qualified_conversation,
             qualifiedFrom: event.qualified_from,
             from: event.from,
-            id: MessageBuilder_1.MessageBuilder.createId(),
+            id: (0, MessageBuilder_1.createId)(),
             messageTimer: 0,
             source,
             state: PayloadBundle_1.PayloadBundleState.INCOMING,

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

@@ -1,15 +1,22 @@
 import { APIClient } from '@wireapp/api-client';
-import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedStatus, NewConversation, QualifiedUserClients, UserClients, ClientMismatch } from '@wireapp/api-client/src/conversation';
+import { Conversation, DefaultConversationRoleName, MutedStatus, NewConversation, QualifiedUserClients, UserClients } 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 { MessageTimer, PayloadBundleState, 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';
+import { AddUsersParams, MLSReturnType, SendMlsMessageParams, SendProteusMessageParams } from './ConversationService.types';
+declare type SendResult = {
+    /** The id of the message sent */
+    id: string;
+    /** the ISO formatted date at which the message was received by the backend */
+    sentAt: string;
+    /** The sending state of the payload (has the payload been succesfully sent or canceled) */
+    state: PayloadBundleState;
+};
 export declare class ConversationService {
     private readonly apiClient;
     private readonly config;
@@ -17,7 +24,6 @@ export declare class ConversationService {
     private readonly mlsService;
     readonly messageTimer: MessageTimer;
     private readonly messageService;
-    private selfConversationId?;
     constructor(apiClient: APIClient, cryptographyService: CryptographyService, config: {
         useQualifiedIds?: boolean;
     }, notificationService: NotificationService, mlsService: MLSService);
@@ -31,8 +37,7 @@ export declare class ConversationService {
      * @returns {Promise<QualifiedUserPreKeyBundleMap}
      */
     private getQualifiedPreKeyBundle;
-    getPreKeyBundleMap(conversationId: string, userIds?: string[] | UserClients): Promise<UserPreKeyBundleMap>;
-    private getSelfConversationId;
+    getPreKeyBundleMap(conversationId: QualifiedId, userIds?: string[] | UserClients): Promise<UserPreKeyBundleMap>;
     private getQualifiedRecipientsForConversation;
     private getRecipientsForConversation;
     /**
@@ -46,33 +51,6 @@ export declare class ConversationService {
     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.
@@ -83,7 +61,7 @@ export declare class ConversationService {
      * @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>;
+    getAllParticipantsClients(conversationId: QualifiedId): 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
@@ -118,9 +96,9 @@ export declare class ConversationService {
     private sendProteusMessage;
     /**
      * Sends a message to a conversation
-     * @return resolves with the sent message
+     * @return resolves with the sending status
      */
-    send<T extends OtrMessage>(params: XOR<SendMlsMessageParams<T>, SendProteusMessageParams<T>>): Promise<T>;
+    send(params: XOR<SendMlsMessageParams, SendProteusMessageParams>): Promise<SendResult>;
     sendTypingStart(conversationId: string): Promise<void>;
     sendTypingStop(conversationId: string): Promise<void>;
     setConversationMutedStatus(conversationId: string, status: MutedStatus, muteTimestamp: number | Date): Promise<void>;
@@ -147,3 +125,4 @@ export declare class ConversationService {
     isMLSConversationEstablished(conversationGroupId: string): Promise<boolean>;
     wipeMLSConversation(conversationId: Uint8Array): Promise<void>;
 }
+export {};

package/src/main/conversation/ConversationService/ConversationService.js

@@ -26,14 +26,12 @@ const protocol_messaging_1 = require("@wireapp/protocol-messaging");
 const conversation_2 = require("../../conversation/");
 const AssetCryptography_1 = require("../../cryptography/AssetCryptography");
 const TypePredicateUtil_1 = require("../../util/TypePredicateUtil");
-const MessageBuilder_1 = require("../message/MessageBuilder");
 const MessageService_1 = require("../message/MessageService");
 const ConversationService_types_1 = require("./ConversationService.types");
 const bazinga64_1 = require("bazinga64");
 const fullyQualifiedClientIdUtils_1 = require("../../util/fullyQualifiedClientIdUtils");
 const mls_1 = require("../../mls");
 const messageSender_1 = require("../message/messageSender");
-const messageGenerator_1 = require("./messageGenerator");
 class ConversationService {
     constructor(apiClient, cryptographyService, config, notificationService, mlsService) {
         this.apiClient = apiClient;
@@ -125,15 +123,6 @@ class ConversationService {
             return bundleMap;
         }, {});
     }
-    async getSelfConversationId() {
-        if (!this.selfConversationId) {
-            const { userId } = this.apiClient.context;
-            const { qualified_id, id } = await this.apiClient.api.conversation.getConversation(userId);
-            const domain = this.config.useQualifiedIds ? qualified_id.domain : '';
-            this.selfConversationId = { id, domain };
-        }
-        return this.selfConversationId;
-    }
     async getQualifiedRecipientsForConversation(conversationId, userIds) {
         if ((0, TypePredicateUtil_1.isQualifiedUserClients)(userIds)) {
             return userIds;
@@ -155,16 +144,16 @@ class ConversationService {
      * @param genericMessage The payload of the message to send
      * @return Resolves with the message sending status from backend
      */
-    async sendGenericMessage(sendingClientId, conversationId, genericMessage, { conversationDomain, userIds, nativePush, sendAsProtobuf, onClientMismatch, targetMode = ConversationService_types_1.MessageTargetMode.NONE, } = {}) {
+    async sendGenericMessage(conversationId, sendingClientId, genericMessage, { userIds, nativePush, sendAsProtobuf, onClientMismatch, targetMode = ConversationService_types_1.MessageTargetMode.NONE, } = {}) {
         const plainText = protocol_messaging_1.GenericMessage.encode(genericMessage).finish();
         if (targetMode !== ConversationService_types_1.MessageTargetMode.NONE && !userIds) {
             throw new Error('Cannot send targetted message when no userIds are given');
         }
-        if (conversationDomain && this.config.useQualifiedIds) {
+        if (conversationId.domain && this.config.useQualifiedIds) {
             if ((0, TypePredicateUtil_1.isStringArray)(userIds) || (0, TypePredicateUtil_1.isUserClients)(userIds)) {
                 throw new Error('Invalid userIds option for sending to federated backend');
             }
-            const recipients = await this.getQualifiedRecipientsForConversation({ id: conversationId, domain: conversationDomain }, userIds);
+            const recipients = await this.getQualifiedRecipientsForConversation(conversationId, userIds);
             let reportMissing;
             if (targetMode === ConversationService_types_1.MessageTargetMode.NONE) {
                 reportMissing = (0, TypePredicateUtil_1.isQualifiedUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
@@ -177,7 +166,7 @@ class ConversationService {
                 reportMissing = false;
             }
             return this.messageService.sendFederatedMessage(sendingClientId, recipients, plainText, {
-                conversationId: { id: conversationId, domain: conversationDomain },
+                conversationId,
                 nativePush,
                 reportMissing,
                 onClientMismatch: mismatch => onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(mismatch, false),
@@ -220,77 +209,6 @@ class ConversationService {
         }
         return userIds;
     }
-    async clearConversation(conversationId, timestamp = new Date(), messageId = MessageBuilder_1.MessageBuilder.createId(), sendAsProtobuf) {
-        if (timestamp instanceof Date) {
-            timestamp = timestamp.getTime();
-        }
-        const content = {
-            clearedTimestamp: timestamp,
-            conversationId,
-        };
-        const clearedMessage = protocol_messaging_1.Cleared.create(content);
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.CLEARED]: clearedMessage,
-            messageId,
-        });
-        const { id: selfConversationId, domain } = await this.getSelfConversationId();
-        await this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, {
-            conversationDomain: domain,
-            sendAsProtobuf,
-        });
-        return {
-            content,
-            conversation: conversationId,
-            from: this.apiClient.context.userId,
-            id: messageId,
-            messageTimer: 0,
-            source: conversation_2.PayloadBundleSource.LOCAL,
-            state: conversation_2.PayloadBundleState.OUTGOING_SENT,
-            timestamp: Date.now(),
-            type: conversation_2.PayloadBundleType.CONVERSATION_CLEAR,
-        };
-    }
-    /**
-     * 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
-     */
-    async sendLastRead(conversationId, lastReadTimestamp, sendingOptions) {
-        const lastRead = new protocol_messaging_1.LastRead({
-            conversationId,
-            lastReadTimestamp,
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.LAST_READ]: lastRead,
-            messageId: MessageBuilder_1.MessageBuilder.createId(),
-        });
-        const { id: selfConversationId, domain: selfConversationDomain } = await this.getSelfConversationId();
-        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, Object.assign({ conversationDomain: selfConversationDomain }, sendingOptions));
-    }
-    /**
-     * 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
-     */
-    async sendCountlySync(countlyId, sendingOptions) {
-        const { id: selfConversationId, domain: selfConversationDomain } = await this.getSelfConversationId();
-        const dataTransfer = new protocol_messaging_1.DataTransfer({
-            trackingIdentifier: {
-                identifier: countlyId,
-            },
-        });
-        const genericMessage = new protocol_messaging_1.GenericMessage({
-            [conversation_2.GenericMessageType.DATA_TRANSFER]: dataTransfer,
-            messageId: MessageBuilder_1.MessageBuilder.createId(),
-        });
-        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, Object.assign({ conversationDomain: selfConversationDomain }, sendingOptions));
-    }
     /**
      * 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.
@@ -301,7 +219,7 @@ class ConversationService {
      * @param {string} conversationId
      * @param {string} conversationDomain? - If given will send the message to the new qualified endpoint
      */
-    getAllParticipantsClients(conversationId, conversationDomain) {
+    getAllParticipantsClients(conversationId) {
         const sendingClientId = this.apiClient.validatedClientId;
         const recipients = {};
         const text = new Uint8Array();
@@ -311,9 +229,9 @@ class ConversationService {
                 // When the mismatch happens, we ask the messageService to cancel the sending
                 return false;
             };
-            if (conversationDomain && this.config.useQualifiedIds) {
+            if (conversationId.domain && this.config.useQualifiedIds) {
                 await this.messageService.sendFederatedMessage(sendingClientId, recipients, text, {
-                    conversationId: { id: conversationId, domain: conversationDomain },
+                    conversationId,
                     onClientMismatch,
                     reportMissing: true,
                 });
@@ -385,13 +303,10 @@ class ConversationService {
     async removeUserFromConversation(conversationId, userId) {
         return this.apiClient.api.conversation.deleteMember(conversationId, userId);
     }
-    async sendProteusMessage(params, genericMessage, content) {
-        var _a;
-        const { userIds, sendAsProtobuf, conversationDomain, nativePush, targetMode, payload, onClientMismatch, onSuccess } = params;
-        const response = await this.sendGenericMessage(this.apiClient.validatedClientId, payload.conversation, genericMessage, {
+    async sendProteusMessage({ userIds, sendAsProtobuf, conversationId, nativePush, targetMode, payload, onClientMismatch, }) {
+        const response = await this.sendGenericMessage(conversationId, this.apiClient.validatedClientId, payload, {
             userIds,
             sendAsProtobuf,
-            conversationDomain,
             nativePush,
             targetMode,
             onClientMismatch,
@@ -401,27 +316,22 @@ class ConversationService {
                 // We warn the consumer that there is a mismatch that did not prevent message sending
                 await (onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(response, true));
             }
-            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(genericMessage, response.time);
         }
-        return Object.assign(Object.assign({}, payload), { content, messageTimer: ((_a = genericMessage.ephemeral) === null || _a === void 0 ? void 0 : _a.expireAfterMillis) || 0, state: response.errored ? conversation_2.PayloadBundleState.CANCELLED : conversation_2.PayloadBundleState.OUTGOING_SENT });
+        return {
+            id: payload.messageId,
+            sentAt: response.time,
+            state: response.errored ? conversation_2.PayloadBundleState.CANCELLED : conversation_2.PayloadBundleState.OUTGOING_SENT,
+        };
     }
     /**
      * Sends a message to a conversation
-     * @return resolves with the sent message
+     * @return resolves with the sending status
      */
     async send(params) {
         function isMLS(params) {
             return params.protocol === conversation_1.ConversationProtocol.MLS;
         }
-        const { payload, onStart } = params;
-        const { genericMessage, content } = (0, messageGenerator_1.generateGenericMessage)(payload, this.messageTimer);
-        if ((await (onStart === null || onStart === void 0 ? void 0 : onStart(genericMessage))) === false) {
-            // If the onStart call returns false, it means the consumer wants to cancel the message sending
-            return Object.assign(Object.assign({}, payload), { state: conversation_2.PayloadBundleState.CANCELLED });
-        }
-        return (0, messageSender_1.sendMessage)(() => isMLS(params)
-            ? this.sendMLSMessage(params, genericMessage, content)
-            : this.sendProteusMessage(params, genericMessage, content));
+        return (0, messageSender_1.sendMessage)(() => (isMLS(params) ? this.sendMLSMessage(params) : this.sendProteusMessage(params)));
     }
     sendTypingStart(conversationId) {
         return this.apiClient.api.conversation.postTyping(conversationId, { status: data_1.CONVERSATION_TYPING.STARTED });
@@ -518,21 +428,22 @@ class ConversationService {
             conversation,
         };
     }
-    async sendMLSMessage(params, genericMessage, content) {
-        var _a, _b;
-        const { groupId, onSuccess, payload } = params;
+    async sendMLSMessage({ payload, groupId }) {
         const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
         // immediately execute pending commits before sending the message
         await this.notificationService.commitPendingProposals({ groupId });
-        const encrypted = await this.mlsService.encryptMessage(groupIdBytes, protocol_messaging_1.GenericMessage.encode(genericMessage).finish());
+        const encrypted = await this.mlsService.encryptMessage(groupIdBytes, protocol_messaging_1.GenericMessage.encode(payload).finish());
+        let sentAt = '';
         try {
             const { time = '' } = await this.apiClient.api.conversation.postMlsMessage(encrypted);
-            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(genericMessage, (time === null || time === void 0 ? void 0 : time.length) > 0 ? time : new Date().toISOString());
-            return Object.assign(Object.assign({}, payload), { content, messageTimer: ((_a = genericMessage.ephemeral) === null || _a === void 0 ? void 0 : _a.expireAfterMillis) || 0, state: conversation_2.PayloadBundleState.OUTGOING_SENT });
-        }
-        catch (_c) {
-            return Object.assign(Object.assign({}, payload), { content, messageTimer: ((_b = genericMessage.ephemeral) === null || _b === void 0 ? void 0 : _b.expireAfterMillis) || 0, state: conversation_2.PayloadBundleState.CANCELLED });
+            sentAt = (time === null || time === void 0 ? void 0 : time.length) > 0 ? time : new Date().toISOString();
         }
+        catch (_a) { }
+        return {
+            id: payload.messageId,
+            sentAt,
+            state: sentAt ? conversation_2.PayloadBundleState.OUTGOING_SENT : conversation_2.PayloadBundleState.CANCELLED,
+        };
     }
     async addUsersToMLSConversation({ qualifiedUserIds, groupId, conversationId, }) {
         const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;

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

@@ -8,10 +8,6 @@ export declare enum MessageTargetMode {
     USERS_CLIENTS = 2
 }
 export interface MessageSendingOptions {
-    /**
-     * The federated domain the server runs on. Should only be set for federation enabled envs
-     */
-    conversationDomain?: string;
     /**
      * can be either a QualifiedId[] or QualfiedUserClients or undefined. The type has some effect on the behavior of the method.
      *    When given undefined the method will fetch both the members of the conversations and their devices. No ClientMismatch can happen in that case
@@ -37,13 +33,6 @@ export interface MessageSendingOptions {
     targetMode?: MessageTargetMode;
 }
 export interface MessageSendingCallbacks {
-    /**
-     * Will be called before a message is actually sent. Returning 'false' will prevent the message from being sent
-     * @param message The message being sent
-     * @return true or undefined if the message should be sent, false if the message sending should be cancelled
-     */
-    onStart?: (message: GenericMessage) => void | boolean | Promise<boolean>;
-    onSuccess?: (message: GenericMessage, sentTime?: string) => void;
     /**
      * Called whenever there is a clientmismatch returned from the server. Will also indicate the sending status of the message (if it was already sent or not)
      *
@@ -67,12 +56,11 @@ export declare type ProtocolParam = {
 /**
  * The message to send to the conversation
  */
-export declare type SendCommonParams<T> = ProtocolParam & {
-    payload: T;
-    onStart?: (message: GenericMessage) => void | boolean | Promise<boolean>;
-    onSuccess?: (message: GenericMessage, sentTime?: string) => void;
+export declare type SendCommonParams = ProtocolParam & {
+    payload: GenericMessage;
 };
-export declare type SendProteusMessageParams<T> = SendCommonParams<T> & MessageSendingOptions & {
+export declare type SendProteusMessageParams = SendCommonParams & MessageSendingOptions & {
+    conversationId: QualifiedId;
     /**
      * Can be either a QualifiedId[], string[], UserClients or QualfiedUserClients. The type has some effect on the behavior of the method. (Needed only for Proteus)
      *    When given a QualifiedId[] or string[] the method will fetch the freshest list of devices for those users (since they are not given by the consumer). As a consequence no ClientMismatch error will trigger and we will ignore missing clients when sending
@@ -84,7 +72,7 @@ export declare type SendProteusMessageParams<T> = SendCommonParams<T> & MessageS
     onClientMismatch?: (status: ClientMismatch | MessageSendingStatus, wasSent: boolean) => void | boolean | Promise<boolean>;
     protocol: ConversationProtocol.PROTEUS;
 };
-export declare type SendMlsMessageParams<T> = SendCommonParams<T> & {
+export declare type SendMlsMessageParams = SendCommonParams & {
     /**
      * The groupId of the conversation to send the message to (Needed only for MLS)
      */

package/src/main/conversation/message/CompositeContentBuilder.js

@@ -45,7 +45,7 @@ class CompositeContentBuilder {
         this.items.push(protocol_messaging_1.Composite.Item.create({ text }));
         return this;
     }
-    addButton(buttonText, id = MessageBuilder_1.MessageBuilder.createId()) {
+    addButton(buttonText, id = (0, MessageBuilder_1.createId)()) {
         this.items.push(protocol_messaging_1.Composite.Item.create({ button: protocol_messaging_1.Button.create({ id, text: buttonText }) }));
         return this;
     }

package/src/main/conversation/message/MessageBuilder.d.ts

@@ -1,96 +1,25 @@
-import { Confirmation } from '@wireapp/protocol-messaging';
-import { AbortReason } from '..';
-import { EncryptedAssetUploaded } from '../../cryptography';
-import { ButtonActionConfirmationContent, ButtonActionContent, CallingContent, FileContent, FileMetaDataContent, ImageContent, KnockContent, LegalHoldStatus, LocationContent, ReactionContent } from '../content';
-import { CompositeContentBuilder } from './CompositeContentBuilder';
-import { ButtonActionConfirmationMessage, ButtonActionMessage, CallMessage, ConfirmationMessage, DeleteMessage, FileAssetAbortMessage, FileAssetMessage, FileAssetMetaDataMessage, HideMessage, ImageAssetMessageOutgoing, LocationMessage, PingMessage, ReactionMessage, ResetSessionMessage } from './OtrMessage';
-import { TextContentBuilder } from './TextContentBuilder';
-interface BaseOptions {
-    conversationId: string;
-    from: string;
-    messageId?: string;
-}
-interface CreateMessageDeleteOption extends BaseOptions {
-    messageIdToDelete: string;
-}
-interface CreateMessageHideOption extends BaseOptions {
-    messageIdToDelete: string;
-    targetConversation: string;
-}
-interface CreateImageOptions extends BaseOptions {
-    expectsReadConfirmation?: boolean;
-    asset: EncryptedAssetUploaded;
-    image: ImageContent;
-    legalHoldStatus?: LegalHoldStatus;
-}
-interface CreateFileOptions extends BaseOptions {
-    expectsReadConfirmation?: boolean;
-    asset: EncryptedAssetUploaded;
-    file: FileContent;
-    legalHoldStatus?: LegalHoldStatus;
-    originalMessageId: string;
-}
-interface CreateEditedTextOptions extends BaseOptions {
-    newMessageText: string;
-    originalMessageId: string;
-}
-interface CreateFileMetadataOptions extends BaseOptions {
-    expectsReadConfirmation?: boolean;
-    legalHoldStatus?: LegalHoldStatus;
-    metaData: FileMetaDataContent;
-}
-interface CreateFileAbortOptions {
-    conversationId: string;
-    expectsReadConfirmation?: boolean;
-    from: string;
-    legalHoldStatus?: LegalHoldStatus;
-    originalMessageId: string;
-    reason: AbortReason;
-}
-interface CreateLocationOptions extends BaseOptions {
-    location: LocationContent;
-}
-interface CreateCallOptions extends BaseOptions {
-    content: CallingContent;
-}
-interface CreateReactionOptions extends BaseOptions {
-    reaction: ReactionContent;
-}
-interface CreateTextOptions extends BaseOptions {
-    text: string;
-}
-interface CreateConfirmationOptions extends BaseOptions {
-    firstMessageId: string;
-    moreMessageIds?: string[];
-    type: Confirmation.Type;
-}
-interface CreatePingOptions extends BaseOptions {
-    ping?: KnockContent;
-}
-interface CreateButtonActionConfirmationOptions extends BaseOptions {
-    content: ButtonActionConfirmationContent;
-}
-interface CreateActionMessageOptions extends BaseOptions {
-    content: ButtonActionContent;
-}
-export declare class MessageBuilder {
-    static createEditedText(payload: CreateEditedTextOptions): TextContentBuilder;
-    static createFileData(payload: CreateFileOptions): FileAssetMessage;
-    static createMessageDelete(payload: CreateMessageDeleteOption): DeleteMessage;
-    static createMessageHide(payload: CreateMessageHideOption): HideMessage;
-    static createFileMetadata(payload: CreateFileMetadataOptions): FileAssetMetaDataMessage;
-    static createFileAbort(payload: CreateFileAbortOptions): FileAssetAbortMessage;
-    static createImage(payload: CreateImageOptions): ImageAssetMessageOutgoing;
-    static createLocation(payload: CreateLocationOptions): LocationMessage;
-    static createCall(payload: CreateCallOptions): CallMessage;
-    static createReaction(payload: CreateReactionOptions): ReactionMessage;
-    static createText(payload: CreateTextOptions): TextContentBuilder;
-    static createConfirmation(payload: CreateConfirmationOptions): ConfirmationMessage;
-    static createButtonActionMessage(payload: CreateActionMessageOptions): ButtonActionMessage;
-    static createButtonActionConfirmationMessage(payload: CreateButtonActionConfirmationOptions): ButtonActionConfirmationMessage;
-    static createComposite(payload: BaseOptions): CompositeContentBuilder;
-    static createPing(payload: CreatePingOptions): PingMessage;
-    static createSessionReset(payload: BaseOptions): ResetSessionMessage;
-    static createId(): string;
-}
-export {};
+import { ButtonActionConfirmationMessage, ButtonActionMessage, CallMessage, ConfirmationMessage, DeleteMessage, EditedTextMessage, FileAssetAbortMessage, FileAssetMessage, FileAssetMetaDataMessage, HideMessage, ImageAssetMessageOutgoing, LocationMessage, PingMessage, ReactionMessage, TextMessage } from './OtrMessage';
+import { IComposite, GenericMessage } from '@wireapp/protocol-messaging';
+import { QualifiedId } from '@wireapp/api-client/src/user';
+export declare function createId(): string;
+export declare function buildButtonActionMessage(payloadBundle: ButtonActionMessage['content']): GenericMessage;
+export declare function buildButtonActionConfirmationMessage(payloadBundle: ButtonActionConfirmationMessage['content']): GenericMessage;
+export declare function buildCompositeMessage(payload: IComposite): GenericMessage;
+export declare function buildConfirmationMessage(payloadBundle: ConfirmationMessage['content']): GenericMessage;
+export declare function buildEditedTextMessage(payloadBundle: EditedTextMessage['content'], messageId?: string): GenericMessage;
+export declare function buildFileDataMessage(payloadBundle: FileAssetMessage['content'], messageId?: string): GenericMessage;
+export declare function buildFileMetaDataMessage(payloadBundle: FileAssetMetaDataMessage['content']): GenericMessage;
+export declare function buildFileAbortMessage(payloadBundle: FileAssetAbortMessage['content'], messageId?: string): GenericMessage;
+export declare function buildLastReadMessage(conversationId: QualifiedId, lastReadTimestamp: number): GenericMessage;
+export declare function buildDataTransferMessage(identifier: string): GenericMessage;
+export declare function buildClearedMessage(conversationId: QualifiedId, timestamp?: number): GenericMessage;
+export declare function buildImageMessage(payloadBundle: ImageAssetMessageOutgoing['content'], messageId?: string): GenericMessage;
+export declare function buildLocationMessage(payloadBundle: LocationMessage['content']): GenericMessage;
+export declare function buildPingMessage(payloadBundle: PingMessage['content']): GenericMessage;
+export declare function buildReactionMessage(payloadBundle: ReactionMessage['content']): GenericMessage;
+export declare function buildSessionResetMessage(): GenericMessage;
+export declare function buildCallMessage(payloadBundle: CallMessage['content']): GenericMessage;
+export declare function buildDeleteMessage(payload: DeleteMessage['content']): GenericMessage;
+export declare function buildHideMessage(payload: HideMessage['content']): GenericMessage;
+export declare function buildTextMessage(payloadBundle: TextMessage['content'], messageId?: string): GenericMessage;
+export declare function wrapInEphemeral(originalGenericMessage: GenericMessage, expireAfterMillis: number): GenericMessage;