@wireapp/core 31.1.3 → 31.1.4

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

@@ -0,0 +1,110 @@
+import { GenericMessage } from '@wireapp/protocol-messaging';
+import { QualifiedUserClients, ClientMismatch, ConversationProtocol, MessageSendingStatus, UserClients, Conversation } from '@wireapp/api-client/src/conversation';
+import { QualifiedId } from '@wireapp/api-client/src/user';
+import { MlsEvent } from '@wireapp/api-client/src/conversation/data/MlsEventData';
+export declare enum MessageTargetMode {
+    NONE = 0,
+    USERS = 1,
+    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
+     *    When given a QualifiedId[] 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
+     *    When given a QualifiedUserClients the method will only send to the clients listed in the userIds. This could lead to ClientMismatch (since the given list of devices might not be the freshest one and new clients could have been created)
+     */
+    userIds?: string[] | QualifiedId[] | UserClients | QualifiedUserClients;
+    /**
+     * Will send the message as a protobuf payload
+     */
+    sendAsProtobuf?: boolean;
+    nativePush?: boolean;
+    /**
+     * Will be called whenever there is a clientmismatch returned from the server. Needs to be combined with a userIds of type QualifiedUserClients
+     */
+    onClientMismatch?: MessageSendingCallbacks['onClientMismatch'];
+    /**
+     * Defines the behavior to use when a mismatch happens on backend side:
+     *     - NONE -> Not a targetted message, we want to send to all the users/clients in the conversation. Will report all missing users and clients (default mode)
+     *     - USERS -> A message targetted to all the clients of the given users (according to params.userIds). Will ignore missing users and only report missing clients for the given params.userIds
+     *     - USERS_CLIENTS -> A message targetted at some specific clients of specific users (according to params.userIds). Will force sending the message even if users or clients are missing
+     */
+    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)
+     *
+     * @param status The mismatch info
+     * @param wasSent Indicate whether the message was already sent or if it can still be canceled
+     * @return
+     */
+    onClientMismatch?: (status: ClientMismatch | MessageSendingStatus, wasSent: boolean) => void | boolean | Promise<boolean>;
+}
+/**
+ *   ######################################################################
+ *   ################ MLS and Proteus implementation types ################
+ *   ######################################################################
+ */
+/**
+ * The protocol to use to send the message (MLS or Proteus)
+ */
+export declare type ProtocolParam = {
+    protocol: ConversationProtocol;
+};
+/**
+ * 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 SendProteusMessageParams<T> = SendCommonParams<T> & MessageSendingOptions & {
+    /**
+     * 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
+     *    When given a QualifiedUserClients or UserClients the method will only send to the clients listed in the userIds. This could lead to ClientMismatch (since the given list of devices might not be the freshest one and new clients could have been created)
+     *    When given a QualifiedId[] or QualifiedUserClients the method will send the message through the federated API endpoint
+     *    When given a string[] or UserClients the method will send the message through the old API endpoint
+     */
+    userIds?: string[] | QualifiedId[] | UserClients | QualifiedUserClients;
+    onClientMismatch?: (status: ClientMismatch | MessageSendingStatus, wasSent: boolean) => void | boolean | Promise<boolean>;
+    protocol: ConversationProtocol.PROTEUS;
+};
+export declare type SendMlsMessageParams<T> = SendCommonParams<T> & {
+    /**
+     * The groupId of the conversation to send the message to (Needed only for MLS)
+     */
+    groupId: string;
+    protocol: ConversationProtocol.MLS;
+};
+export declare type QualifiedUsers = QualifiedId & {
+    skipOwn?: string;
+};
+export declare type AddUsersParams = {
+    conversationId: QualifiedId;
+    qualifiedUserIds: QualifiedId[];
+    groupId?: string;
+};
+export declare type RemoveUsersParams = {
+    conversationId: QualifiedId;
+    qualifiedUserIds: QualifiedId[];
+    groupId: string;
+};
+export declare type MLSReturnType = {
+    events: MlsEvent[];
+    conversation: Conversation;
+};

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

@@ -0,0 +1,28 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageTargetMode = void 0;
+var MessageTargetMode;
+(function (MessageTargetMode) {
+    MessageTargetMode[MessageTargetMode["NONE"] = 0] = "NONE";
+    MessageTargetMode[MessageTargetMode["USERS"] = 1] = "USERS";
+    MessageTargetMode[MessageTargetMode["USERS_CLIENTS"] = 2] = "USERS_CLIENTS";
+})(MessageTargetMode = exports.MessageTargetMode || (exports.MessageTargetMode = {}));
+//# sourceMappingURL=ConversationService.types.js.map

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

@@ -0,0 +1,2 @@
+export * from './ConversationService.types';
+export * from './ConversationService';

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

@@ -0,0 +1,37 @@
+"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("./ConversationService.types"), exports);
+__exportStar(require("./ConversationService"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+import { OtrMessage } from '../message/OtrMessage';
+import { GenericMessage } from '@wireapp/protocol-messaging';
+import { MessageTimer } from '../MessageTimer';
+interface GeneratedMessage<T extends OtrMessage> {
+    genericMessage: GenericMessage;
+    content: T['content'];
+}
+export declare function generateGenericMessage<T extends OtrMessage>(payload: T, messageTimer: MessageTimer): GeneratedMessage<T>;
+export {};

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

@@ -0,0 +1,313 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGenericMessage = void 0;
+const protocol_messaging_1 = require("@wireapp/protocol-messaging");
+const PayloadBundle_1 = require("../message/PayloadBundle");
+const MessageToProtoMapper_1 = require("../message/MessageToProtoMapper");
+const GenericMessageType_1 = require("../GenericMessageType");
+const AssetTransferState_1 = require("../AssetTransferState");
+function generateGenericMessage(payload, messageTimer) {
+    const content = payload.content;
+    switch (payload.type) {
+        case PayloadBundle_1.PayloadBundleType.ASSET:
+            return { genericMessage: generateFileDataGenericMessage(payload, messageTimer), content };
+        case PayloadBundle_1.PayloadBundleType.ASSET_ABORT:
+            return { genericMessage: generateFileAbortGenericMessage(payload, messageTimer), content };
+        case PayloadBundle_1.PayloadBundleType.ASSET_META:
+            return { genericMessage: generateFileMetaDataGenericMessage(payload, messageTimer), content };
+        case PayloadBundle_1.PayloadBundleType.ASSET_IMAGE:
+            return generateImageGenericMessage(payload, messageTimer);
+        case PayloadBundle_1.PayloadBundleType.BUTTON_ACTION:
+            return { genericMessage: generateButtonActionGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.BUTTON_ACTION_CONFIRMATION:
+            return { genericMessage: generateButtonActionConfirmationGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.CALL:
+            return { genericMessage: generateCallGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.CLIENT_ACTION:
+            return { genericMessage: generateSessionResetGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.COMPOSITE:
+            return { genericMessage: generateCompositeGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.CONFIRMATION:
+            return { genericMessage: generateConfirmationGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.LOCATION:
+            return { genericMessage: generateLocationGenericMessage(payload, messageTimer), content };
+        case PayloadBundle_1.PayloadBundleType.MESSAGE_EDIT:
+            return { genericMessage: generateEditedTextGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.PING:
+            return { genericMessage: generatePingGenericMessage(payload, messageTimer), content };
+        case PayloadBundle_1.PayloadBundleType.REACTION:
+            return { genericMessage: generateReactionGenericMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.TEXT:
+            return { genericMessage: generateTextGenericMessage(payload, messageTimer), content };
+        case PayloadBundle_1.PayloadBundleType.MESSAGE_DELETE:
+            return { genericMessage: generateDeleteMessage(payload), content };
+        case PayloadBundle_1.PayloadBundleType.MESSAGE_HIDE:
+            return { genericMessage: generateHideMessage(payload), content };
+        /**
+         * ToDo: Create Generic implementation for everything else
+         */
+        default:
+            throw new Error(`No send method implemented for "${payload['type']}".`);
+    }
+}
+exports.generateGenericMessage = generateGenericMessage;
+function generateButtonActionGenericMessage(payloadBundle) {
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.BUTTON_ACTION]: protocol_messaging_1.ButtonAction.create(payloadBundle.content),
+        messageId: payloadBundle.id,
+    });
+}
+function generateButtonActionConfirmationGenericMessage(payloadBundle) {
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.BUTTON_ACTION_CONFIRMATION]: protocol_messaging_1.ButtonActionConfirmation.create(payloadBundle.content),
+        messageId: payloadBundle.id,
+    });
+}
+function generateCompositeGenericMessage(payloadBundle) {
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.COMPOSITE]: protocol_messaging_1.Composite.create(payloadBundle.content),
+        messageId: payloadBundle.id,
+    });
+}
+function generateConfirmationGenericMessage(payloadBundle) {
+    const content = protocol_messaging_1.Confirmation.create(payloadBundle.content);
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.CONFIRMATION]: content,
+        messageId: payloadBundle.id,
+    });
+}
+function generateEditedTextGenericMessage(payloadBundle) {
+    const editedMessage = protocol_messaging_1.MessageEdit.create({
+        replacingMessageId: payloadBundle.content.originalMessageId,
+        text: MessageToProtoMapper_1.MessageToProtoMapper.mapText(payloadBundle),
+    });
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.EDITED]: editedMessage,
+        messageId: payloadBundle.id,
+    });
+}
+function generateFileDataGenericMessage(payloadBundle, messageTimer) {
+    if (!payloadBundle.content) {
+        throw new Error('No content for sendFileData provided.');
+    }
+    const { asset, expectsReadConfirmation, legalHoldStatus } = payloadBundle.content;
+    const remoteData = protocol_messaging_1.Asset.RemoteData.create({
+        assetId: asset.key,
+        assetToken: asset.token,
+        otrKey: asset.keyBytes,
+        sha256: asset.sha256,
+        assetDomain: asset.domain,
+    });
+    const assetMessage = protocol_messaging_1.Asset.create({
+        expectsReadConfirmation,
+        legalHoldStatus,
+        uploaded: remoteData,
+    });
+    assetMessage.status = AssetTransferState_1.AssetTransferState.UPLOADED;
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.ASSET]: assetMessage,
+        messageId: payloadBundle.id,
+    });
+    const expireAfterMillis = messageTimer.getMessageTimer(payloadBundle.conversation);
+    return expireAfterMillis > 0 ? createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
+}
+function generateFileMetaDataGenericMessage(payloadBundle, messageTimer) {
+    if (!payloadBundle.content) {
+        throw new Error('No content for sendFileMetaData provided.');
+    }
+    const { expectsReadConfirmation, legalHoldStatus, metaData } = payloadBundle.content;
+    const original = protocol_messaging_1.Asset.Original.create({
+        audio: metaData.audio,
+        mimeType: metaData.type,
+        name: metaData.name,
+        size: metaData.length,
+        video: metaData.video,
+        image: metaData.image,
+    });
+    const assetMessage = protocol_messaging_1.Asset.create({
+        expectsReadConfirmation,
+        legalHoldStatus,
+        original,
+    });
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.ASSET]: assetMessage,
+        messageId: payloadBundle.id,
+    });
+    const expireAfterMillis = messageTimer.getMessageTimer(payloadBundle.conversation);
+    return expireAfterMillis > 0 ? createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
+}
+function generateFileAbortGenericMessage(payloadBundle, messageTimer) {
+    if (!payloadBundle.content) {
+        throw new Error('No content for sendFileAbort provided.');
+    }
+    const { expectsReadConfirmation, legalHoldStatus, reason } = payloadBundle.content;
+    const assetMessage = protocol_messaging_1.Asset.create({
+        expectsReadConfirmation,
+        legalHoldStatus,
+        notUploaded: reason,
+    });
+    assetMessage.status = AssetTransferState_1.AssetTransferState.NOT_UPLOADED;
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.ASSET]: assetMessage,
+        messageId: payloadBundle.id,
+    });
+    const expireAfterMillis = messageTimer.getMessageTimer(payloadBundle.conversation);
+    return expireAfterMillis > 0 ? createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
+}
+function generateImageGenericMessage(payloadBundle, messageTimer) {
+    const imageAsset = generateAsset(payloadBundle);
+    let genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.ASSET]: imageAsset,
+        messageId: payloadBundle.id,
+    });
+    const expireAfterMillis = messageTimer.getMessageTimer(payloadBundle.conversation);
+    if (expireAfterMillis) {
+        genericMessage = createEphemeral(genericMessage, expireAfterMillis);
+    }
+    return { genericMessage, content: imageAsset };
+}
+function generateLocationGenericMessage(payloadBundle, messageTimer) {
+    const { expectsReadConfirmation, latitude, legalHoldStatus, longitude, name, zoom } = payloadBundle.content;
+    const locationMessage = protocol_messaging_1.Location.create({
+        expectsReadConfirmation,
+        latitude,
+        legalHoldStatus,
+        longitude,
+        name,
+        zoom,
+    });
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.LOCATION]: locationMessage,
+        messageId: payloadBundle.id,
+    });
+    const expireAfterMillis = messageTimer.getMessageTimer(payloadBundle.conversation);
+    return expireAfterMillis > 0 ? createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
+}
+function generatePingGenericMessage(payloadBundle, messageTimer) {
+    const content = protocol_messaging_1.Knock.create(payloadBundle.content);
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.KNOCK]: content,
+        messageId: payloadBundle.id,
+    });
+    const expireAfterMillis = messageTimer.getMessageTimer(payloadBundle.conversation);
+    return expireAfterMillis > 0 ? createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
+}
+function generateReactionGenericMessage(payloadBundle) {
+    const { legalHoldStatus, originalMessageId, type } = payloadBundle.content;
+    const reaction = protocol_messaging_1.Reaction.create({
+        emoji: type,
+        legalHoldStatus,
+        messageId: originalMessageId,
+    });
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.REACTION]: reaction,
+        messageId: payloadBundle.id,
+    });
+    return genericMessage;
+}
+function generateSessionResetGenericMessage(payload) {
+    if (payload.content.clientAction !== protocol_messaging_1.ClientAction.RESET_SESSION) {
+        throw new Error(`No send method implemented for "${payload.type}" and ClientAction "${payload.content}".`);
+    }
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.CLIENT_ACTION]: protocol_messaging_1.ClientAction.RESET_SESSION,
+        messageId: payload.id,
+    });
+}
+function generateCallGenericMessage(payloadBundle) {
+    const callMessage = protocol_messaging_1.Calling.create({
+        content: payloadBundle.content,
+    });
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.CALLING]: callMessage,
+        messageId: payloadBundle.id,
+    });
+}
+function generateDeleteMessage(payload) {
+    const content = protocol_messaging_1.MessageDelete.create({
+        messageId: payload.content.messageId,
+    });
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.DELETED]: content,
+        messageId: payload.id,
+    });
+}
+function generateHideMessage(payload) {
+    const content = protocol_messaging_1.MessageHide.create({
+        messageId: payload.content.messageId,
+        conversationId: payload.content.conversationId,
+    });
+    return protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.HIDDEN]: content,
+        messageId: payload.id,
+    });
+}
+function generateTextGenericMessage(payloadBundle, messageTimer) {
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        messageId: payloadBundle.id,
+        [GenericMessageType_1.GenericMessageType.TEXT]: MessageToProtoMapper_1.MessageToProtoMapper.mapText(payloadBundle),
+    });
+    const expireAfterMillis = messageTimer.getMessageTimer(payloadBundle.conversation);
+    return expireAfterMillis > 0 ? createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
+}
+function generateAsset(payloadBundle) {
+    if (!payloadBundle.content) {
+        throw new Error('No content for sendImage provided.');
+    }
+    const { asset, expectsReadConfirmation, image, legalHoldStatus } = payloadBundle.content;
+    const imageMetadata = protocol_messaging_1.Asset.ImageMetaData.create({
+        height: image.height,
+        width: image.width,
+    });
+    const original = protocol_messaging_1.Asset.Original.create({
+        [GenericMessageType_1.GenericMessageType.IMAGE]: imageMetadata,
+        mimeType: image.type,
+        name: null,
+        size: image.data.length,
+    });
+    const remoteData = protocol_messaging_1.Asset.RemoteData.create({
+        assetId: asset.key,
+        assetToken: asset.token,
+        assetDomain: asset.domain,
+        otrKey: asset.keyBytes,
+        sha256: asset.sha256,
+    });
+    const assetMessage = protocol_messaging_1.Asset.create({
+        expectsReadConfirmation,
+        legalHoldStatus,
+        original,
+        uploaded: remoteData,
+    });
+    assetMessage.status = AssetTransferState_1.AssetTransferState.UPLOADED;
+    return assetMessage;
+}
+function createEphemeral(originalGenericMessage, expireAfterMillis) {
+    const ephemeralMessage = protocol_messaging_1.Ephemeral.create({
+        expireAfterMillis,
+        [originalGenericMessage.content]: originalGenericMessage[originalGenericMessage.content],
+    });
+    const genericMessage = protocol_messaging_1.GenericMessage.create({
+        [GenericMessageType_1.GenericMessageType.EPHEMERAL]: ephemeralMessage,
+        messageId: originalGenericMessage.messageId,
+    });
+    return genericMessage;
+}
+//# sourceMappingURL=messageGenerator.js.map

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

@@ -0,0 +1,25 @@
+export declare enum GenericMessageType {
+    ASSET = "asset",
+    ASSET_ABORT = "assetAbort",
+    ASSET_META = "assetMeta",
+    AVAILABILITY = "availability",
+    BUTTON_ACTION = "buttonAction",
+    BUTTON_ACTION_CONFIRMATION = "buttonActionConfirmation",
+    CALLING = "calling",
+    CLEARED = "cleared",
+    CLIENT_ACTION = "clientAction",
+    COMPOSITE = "composite",
+    CONFIRMATION = "confirmation",
+    DATA_TRANSFER = "dataTransfer",
+    DELETED = "deleted",
+    EDITED = "edited",
+    EPHEMERAL = "ephemeral",
+    EXTERNAL = "external",
+    HIDDEN = "hidden",
+    IMAGE = "image",
+    KNOCK = "knock",
+    LAST_READ = "lastRead",
+    LOCATION = "location",
+    REACTION = "reaction",
+    TEXT = "text"
+}

package/src/main/conversation/GenericMessageType.js

@@ -0,0 +1,49 @@
+"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.GenericMessageType = void 0;
+// Enum values come from "IGenericMessage" properties in "Protobuf.d.ts"
+var GenericMessageType;
+(function (GenericMessageType) {
+    GenericMessageType["ASSET"] = "asset";
+    GenericMessageType["ASSET_ABORT"] = "assetAbort";
+    GenericMessageType["ASSET_META"] = "assetMeta";
+    GenericMessageType["AVAILABILITY"] = "availability";
+    GenericMessageType["BUTTON_ACTION"] = "buttonAction";
+    GenericMessageType["BUTTON_ACTION_CONFIRMATION"] = "buttonActionConfirmation";
+    GenericMessageType["CALLING"] = "calling";
+    GenericMessageType["CLEARED"] = "cleared";
+    GenericMessageType["CLIENT_ACTION"] = "clientAction";
+    GenericMessageType["COMPOSITE"] = "composite";
+    GenericMessageType["CONFIRMATION"] = "confirmation";
+    GenericMessageType["DATA_TRANSFER"] = "dataTransfer";
+    GenericMessageType["DELETED"] = "deleted";
+    GenericMessageType["EDITED"] = "edited";
+    GenericMessageType["EPHEMERAL"] = "ephemeral";
+    GenericMessageType["EXTERNAL"] = "external";
+    GenericMessageType["HIDDEN"] = "hidden";
+    GenericMessageType["IMAGE"] = "image";
+    GenericMessageType["KNOCK"] = "knock";
+    GenericMessageType["LAST_READ"] = "lastRead";
+    GenericMessageType["LOCATION"] = "location";
+    GenericMessageType["REACTION"] = "reaction";
+    GenericMessageType["TEXT"] = "text";
+})(GenericMessageType = exports.GenericMessageType || (exports.GenericMessageType = {}));
+//# sourceMappingURL=GenericMessageType.js.map

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

@@ -0,0 +1,10 @@
+export declare class MessageTimer {
+    private readonly conversationLevelTimers;
+    private readonly messageLevelTimers;
+    constructor();
+    getConversationLevelTimer(conversationId: string): number;
+    getMessageLevelTimer(conversationId: string): number;
+    getMessageTimer(conversationId: string): number;
+    setConversationLevelTimer(conversationId: string, messageTimer: number): void;
+    setMessageLevelTimer(conversationId: string, messageTimer: number): void;
+}

package/src/main/conversation/MessageTimer/MessageTimer.js

@@ -0,0 +1,54 @@
+"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.MessageTimer = void 0;
+class MessageTimer {
+    constructor() {
+        this.conversationLevelTimers = new Map();
+        this.messageLevelTimers = new Map();
+    }
+    getConversationLevelTimer(conversationId) {
+        return this.conversationLevelTimers.get(conversationId) || 0;
+    }
+    getMessageLevelTimer(conversationId) {
+        return this.messageLevelTimers.get(conversationId) || 0;
+    }
+    getMessageTimer(conversationId) {
+        return this.getConversationLevelTimer(conversationId) || this.getMessageLevelTimer(conversationId);
+    }
+    setConversationLevelTimer(conversationId, messageTimer) {
+        if (messageTimer === 0) {
+            this.conversationLevelTimers.delete(conversationId);
+        }
+        else {
+            this.conversationLevelTimers.set(conversationId, messageTimer);
+        }
+    }
+    setMessageLevelTimer(conversationId, messageTimer) {
+        if (messageTimer === 0) {
+            this.messageLevelTimers.delete(conversationId);
+        }
+        else {
+            this.messageLevelTimers.set(conversationId, messageTimer);
+        }
+    }
+}
+exports.MessageTimer = MessageTimer;
+//# sourceMappingURL=MessageTimer.js.map

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

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