@wireapp/protocol-messaging 1.30.0 → 1.36.0

package/package.json

@@ -19,9 +19,9 @@
   "repository": "https://github.com/wireapp/generic-message-proto.git",
   "scripts": {
     "dist": "node web/compile.js",
-    "postversion": "git push --force --tags && npm publish",
+    "postversion": "git push origin master --tags && npm publish",
     "preversion": "git checkout master && git pull && yarn && yarn dist && yarn test",
     "test": "tsc --noEmit"
   },
-  "version": "1.30.0"
+  "version": "1.36.0"
 }

package/proto/messages.proto

@@ -303,6 +303,7 @@ message Asset {
     optional string asset_id = 3;
     // optional bytes asset_token = 4; // deprecated - changed type to string
     optional string asset_token = 5;
+    optional string asset_domain = 7;
     optional EncryptionAlgorithm encryption = 6;
   }
 

package/proto/otr.proto

@@ -19,6 +19,8 @@
 
 syntax = "proto2";
 
+package proteus;
+
 option java_package = "com.wire.messages";
 option java_outer_classname = "Otr";
 option optimize_for = LITE_RUNTIME;
@@ -42,17 +44,23 @@ message ClientEntry {
 }
 
 message UserEntry {
-    required UserId          user              = 1;
-    repeated ClientEntry     clients           = 2;
-    optional QualifiedUserId qualified_user_id = 3;
+    required UserId      user    = 1;
+    repeated ClientEntry clients = 2;
+}
+
+message QualifiedUserEntry {
+  required string domain = 1;
+  repeated UserEntry entries = 2;
 }
 
+enum Priority {
+  // 0 is reserved for errors
+  LOW_PRIORITY = 1;
+  HIGH_PRIORITY = 2;
+};
+
+// deprecated, use QualifiedNewOtrMessage
 message NewOtrMessage {
-    enum Priority {
-      // 0 is reserved for errors
-      LOW_PRIORITY = 1;
-      HIGH_PRIORITY = 2;
-    };
     required ClientId  sender          = 1;
     repeated UserEntry recipients      = 2;
     optional bool      native_push     = 3 [default = true];
@@ -62,6 +70,36 @@ message NewOtrMessage {
     repeated UserId    report_missing  = 7;
 }
 
+message QualifiedNewOtrMessage {
+    required ClientId                  sender          = 1;
+    repeated QualifiedUserEntry        recipients      = 2;
+    optional bool                      native_push     = 3 [default = true];
+    optional bytes                     blob            = 4;
+    optional Priority                  native_priority = 5;
+    optional bool                      transient       = 6;
+    // For more details please refer to backend swagger at
+    // https://staging-nginz-https.zinfra.io/api/swagger-ui/
+    oneof client_mismatch_strategy {
+        ClientMismatchStrategy.ReportAll  report_all   = 7;
+        ClientMismatchStrategy.IgnoreAll  ignore_all   = 8;
+        ClientMismatchStrategy.ReportOnly report_only  = 9;
+        ClientMismatchStrategy.IgnoreOnly ignore_only  = 10;
+    }
+}
+
+message ClientMismatchStrategy {
+    message ReportAll {}
+    message IgnoreAll {}
+
+    message ReportOnly {
+        repeated QualifiedUserId user_ids = 1;
+    }
+
+    message IgnoreOnly {
+        repeated QualifiedUserId user_ids = 1;
+    }
+}
+
 message OtrAssetMeta {
     required ClientId  sender      = 1;
     repeated UserEntry recipients  = 2;

package/web/messages.d.ts

@@ -802,6 +802,7 @@ export namespace Asset {
         sha256: Uint8Array;
         assetId?: (string|null);
         assetToken?: (string|null);
+        assetDomain?: (string|null);
         encryption?: (EncryptionAlgorithm|null);
     }
 
@@ -811,6 +812,7 @@ export namespace Asset {
         public sha256: Uint8Array;
         public assetId: string;
         public assetToken: string;
+        public assetDomain: string;
         public encryption: EncryptionAlgorithm;
         public static create(properties?: Asset.IRemoteData): Asset.RemoteData;
         public static encode(message: Asset.IRemoteData, writer?: $protobuf.Writer): $protobuf.Writer;

package/web/messages.js

@@ -9113,6 +9113,7 @@ $root.Asset = (function() {
          * @property {Uint8Array} sha256 RemoteData sha256
          * @property {string|null} [assetId] RemoteData assetId
          * @property {string|null} [assetToken] RemoteData assetToken
+         * @property {string|null} [assetDomain] RemoteData assetDomain
          * @property {EncryptionAlgorithm|null} [encryption] RemoteData encryption
          */
 
@@ -9163,6 +9164,14 @@ $root.Asset = (function() {
          */
         RemoteData.prototype.assetToken = "";
 
+        /**
+         * RemoteData assetDomain.
+         * @member {string} assetDomain
+         * @memberof Asset.RemoteData
+         * @instance
+         */
+        RemoteData.prototype.assetDomain = "";
+
         /**
          * RemoteData encryption.
          * @member {EncryptionAlgorithm} encryption
@@ -9203,6 +9212,8 @@ $root.Asset = (function() {
                 writer.uint32(/* id 5, wireType 2 =*/42).string(message.assetToken);
             if (message.encryption != null && Object.hasOwnProperty.call(message, "encryption"))
                 writer.uint32(/* id 6, wireType 0 =*/48).int32(message.encryption);
+            if (message.assetDomain != null && Object.hasOwnProperty.call(message, "assetDomain"))
+                writer.uint32(/* id 7, wireType 2 =*/58).string(message.assetDomain);
             return writer;
         };
 
@@ -9249,6 +9260,9 @@ $root.Asset = (function() {
                 case 5:
                     message.assetToken = reader.string();
                     break;
+                case 7:
+                    message.assetDomain = reader.string();
+                    break;
                 case 6:
                     message.encryption = reader.int32();
                     break;
@@ -9301,6 +9315,9 @@ $root.Asset = (function() {
             if (message.assetToken != null && message.hasOwnProperty("assetToken"))
                 if (!$util.isString(message.assetToken))
                     return "assetToken: string expected";
+            if (message.assetDomain != null && message.hasOwnProperty("assetDomain"))
+                if (!$util.isString(message.assetDomain))
+                    return "assetDomain: string expected";
             if (message.encryption != null && message.hasOwnProperty("encryption"))
                 switch (message.encryption) {
                 default:
@@ -9338,6 +9355,8 @@ $root.Asset = (function() {
                 message.assetId = String(object.assetId);
             if (object.assetToken != null)
                 message.assetToken = String(object.assetToken);
+            if (object.assetDomain != null)
+                message.assetDomain = String(object.assetDomain);
             switch (object.encryption) {
             case "AES_CBC":
             case 0:
@@ -9382,6 +9401,7 @@ $root.Asset = (function() {
                 object.assetId = "";
                 object.assetToken = "";
                 object.encryption = options.enums === String ? "AES_CBC" : 0;
+                object.assetDomain = "";
             }
             if (message.otrKey != null && message.hasOwnProperty("otrKey"))
                 object.otrKey = options.bytes === String ? $util.base64.encode(message.otrKey, 0, message.otrKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.otrKey) : message.otrKey;
@@ -9393,6 +9413,8 @@ $root.Asset = (function() {
                 object.assetToken = message.assetToken;
             if (message.encryption != null && message.hasOwnProperty("encryption"))
                 object.encryption = options.enums === String ? $root.EncryptionAlgorithm[message.encryption] : message.encryption;
+            if (message.assetDomain != null && message.hasOwnProperty("assetDomain"))
+                object.assetDomain = message.assetDomain;
             return object;
         };
 

package/web/otr.d.ts

@@ -1,160 +1,302 @@
 import * as $protobuf from "protobufjs";
-export interface IUserId {
-    uuid: Uint8Array;
-}
+export namespace proteus {
 
-export class UserId implements IUserId {
-    constructor(properties?: IUserId);
-    public uuid: Uint8Array;
-    public static create(properties?: IUserId): UserId;
-    public static encode(message: IUserId, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static encodeDelimited(message: IUserId, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UserId;
-    public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UserId;
-    public static verify(message: { [k: string]: any }): (string|null);
-    public static fromObject(object: { [k: string]: any }): UserId;
-    public static toObject(message: UserId, options?: $protobuf.IConversionOptions): { [k: string]: any };
-    public toJSON(): { [k: string]: any };
-}
+    interface IUserId {
+        uuid: Uint8Array;
+    }
 
-export interface IQualifiedUserId {
-    id: string;
-    domain: string;
-}
+    class UserId implements IUserId {
+        constructor(properties?: proteus.IUserId);
+        public uuid: Uint8Array;
+        public static create(properties?: proteus.IUserId): proteus.UserId;
+        public static encode(message: proteus.IUserId, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IUserId, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.UserId;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.UserId;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.UserId;
+        public static toObject(message: proteus.UserId, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
 
-export class QualifiedUserId implements IQualifiedUserId {
-    constructor(properties?: IQualifiedUserId);
-    public id: string;
-    public domain: string;
-    public static create(properties?: IQualifiedUserId): QualifiedUserId;
-    public static encode(message: IQualifiedUserId, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static encodeDelimited(message: IQualifiedUserId, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): QualifiedUserId;
-    public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): QualifiedUserId;
-    public static verify(message: { [k: string]: any }): (string|null);
-    public static fromObject(object: { [k: string]: any }): QualifiedUserId;
-    public static toObject(message: QualifiedUserId, options?: $protobuf.IConversionOptions): { [k: string]: any };
-    public toJSON(): { [k: string]: any };
-}
+    interface IQualifiedUserId {
+        id: string;
+        domain: string;
+    }
 
-export interface IClientId {
-    client: (number|Long);
-}
+    class QualifiedUserId implements IQualifiedUserId {
+        constructor(properties?: proteus.IQualifiedUserId);
+        public id: string;
+        public domain: string;
+        public static create(properties?: proteus.IQualifiedUserId): proteus.QualifiedUserId;
+        public static encode(message: proteus.IQualifiedUserId, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IQualifiedUserId, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.QualifiedUserId;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.QualifiedUserId;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.QualifiedUserId;
+        public static toObject(message: proteus.QualifiedUserId, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
 
-export class ClientId implements IClientId {
-    constructor(properties?: IClientId);
-    public client: (number|Long);
-    public static create(properties?: IClientId): ClientId;
-    public static encode(message: IClientId, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static encodeDelimited(message: IClientId, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ClientId;
-    public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ClientId;
-    public static verify(message: { [k: string]: any }): (string|null);
-    public static fromObject(object: { [k: string]: any }): ClientId;
-    public static toObject(message: ClientId, options?: $protobuf.IConversionOptions): { [k: string]: any };
-    public toJSON(): { [k: string]: any };
-}
+    interface IClientId {
+        client: (number|Long);
+    }
 
-export interface IClientEntry {
-    client: IClientId;
-    text: Uint8Array;
-}
+    class ClientId implements IClientId {
+        constructor(properties?: proteus.IClientId);
+        public client: (number|Long);
+        public static create(properties?: proteus.IClientId): proteus.ClientId;
+        public static encode(message: proteus.IClientId, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IClientId, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.ClientId;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.ClientId;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.ClientId;
+        public static toObject(message: proteus.ClientId, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
 
-export class ClientEntry implements IClientEntry {
-    constructor(properties?: IClientEntry);
-    public client: IClientId;
-    public text: Uint8Array;
-    public static create(properties?: IClientEntry): ClientEntry;
-    public static encode(message: IClientEntry, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static encodeDelimited(message: IClientEntry, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): ClientEntry;
-    public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): ClientEntry;
-    public static verify(message: { [k: string]: any }): (string|null);
-    public static fromObject(object: { [k: string]: any }): ClientEntry;
-    public static toObject(message: ClientEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
-    public toJSON(): { [k: string]: any };
-}
+    interface IClientEntry {
+        client: proteus.IClientId;
+        text: Uint8Array;
+    }
 
-export interface IUserEntry {
-    user: IUserId;
-    clients?: (IClientEntry[]|null);
-    qualifiedUserId?: (IQualifiedUserId|null);
-}
+    class ClientEntry implements IClientEntry {
+        constructor(properties?: proteus.IClientEntry);
+        public client: proteus.IClientId;
+        public text: Uint8Array;
+        public static create(properties?: proteus.IClientEntry): proteus.ClientEntry;
+        public static encode(message: proteus.IClientEntry, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IClientEntry, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.ClientEntry;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.ClientEntry;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.ClientEntry;
+        public static toObject(message: proteus.ClientEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
 
-export class UserEntry implements IUserEntry {
-    constructor(properties?: IUserEntry);
-    public user: IUserId;
-    public clients: IClientEntry[];
-    public qualifiedUserId?: (IQualifiedUserId|null);
-    public static create(properties?: IUserEntry): UserEntry;
-    public static encode(message: IUserEntry, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static encodeDelimited(message: IUserEntry, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): UserEntry;
-    public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): UserEntry;
-    public static verify(message: { [k: string]: any }): (string|null);
-    public static fromObject(object: { [k: string]: any }): UserEntry;
-    public static toObject(message: UserEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
-    public toJSON(): { [k: string]: any };
-}
+    interface IUserEntry {
+        user: proteus.IUserId;
+        clients?: (proteus.IClientEntry[]|null);
+    }
 
-export interface INewOtrMessage {
-    sender: IClientId;
-    recipients?: (IUserEntry[]|null);
-    nativePush?: (boolean|null);
-    blob?: (Uint8Array|null);
-    nativePriority?: (NewOtrMessage.Priority|null);
-    transient?: (boolean|null);
-    reportMissing?: (IUserId[]|null);
-}
+    class UserEntry implements IUserEntry {
+        constructor(properties?: proteus.IUserEntry);
+        public user: proteus.IUserId;
+        public clients: proteus.IClientEntry[];
+        public static create(properties?: proteus.IUserEntry): proteus.UserEntry;
+        public static encode(message: proteus.IUserEntry, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IUserEntry, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.UserEntry;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.UserEntry;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.UserEntry;
+        public static toObject(message: proteus.UserEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
 
-export class NewOtrMessage implements INewOtrMessage {
-    constructor(properties?: INewOtrMessage);
-    public sender: IClientId;
-    public recipients: IUserEntry[];
-    public nativePush: boolean;
-    public blob: Uint8Array;
-    public nativePriority: NewOtrMessage.Priority;
-    public transient: boolean;
-    public reportMissing: IUserId[];
-    public static create(properties?: INewOtrMessage): NewOtrMessage;
-    public static encode(message: INewOtrMessage, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static encodeDelimited(message: INewOtrMessage, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): NewOtrMessage;
-    public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): NewOtrMessage;
-    public static verify(message: { [k: string]: any }): (string|null);
-    public static fromObject(object: { [k: string]: any }): NewOtrMessage;
-    public static toObject(message: NewOtrMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
-    public toJSON(): { [k: string]: any };
-}
+    interface IQualifiedUserEntry {
+        domain: string;
+        entries?: (proteus.IUserEntry[]|null);
+    }
 
-export namespace NewOtrMessage {
+    class QualifiedUserEntry implements IQualifiedUserEntry {
+        constructor(properties?: proteus.IQualifiedUserEntry);
+        public domain: string;
+        public entries: proteus.IUserEntry[];
+        public static create(properties?: proteus.IQualifiedUserEntry): proteus.QualifiedUserEntry;
+        public static encode(message: proteus.IQualifiedUserEntry, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IQualifiedUserEntry, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.QualifiedUserEntry;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.QualifiedUserEntry;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.QualifiedUserEntry;
+        public static toObject(message: proteus.QualifiedUserEntry, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
 
     enum Priority {
         LOW_PRIORITY = 1,
         HIGH_PRIORITY = 2
     }
-}
 
-export interface IOtrAssetMeta {
-    sender: IClientId;
-    recipients?: (IUserEntry[]|null);
-    isInline?: (boolean|null);
-    nativePush?: (boolean|null);
-}
+    interface INewOtrMessage {
+        sender: proteus.IClientId;
+        recipients?: (proteus.IUserEntry[]|null);
+        nativePush?: (boolean|null);
+        blob?: (Uint8Array|null);
+        nativePriority?: (proteus.Priority|null);
+        transient?: (boolean|null);
+        reportMissing?: (proteus.IUserId[]|null);
+    }
+
+    class NewOtrMessage implements INewOtrMessage {
+        constructor(properties?: proteus.INewOtrMessage);
+        public sender: proteus.IClientId;
+        public recipients: proteus.IUserEntry[];
+        public nativePush: boolean;
+        public blob: Uint8Array;
+        public nativePriority: proteus.Priority;
+        public transient: boolean;
+        public reportMissing: proteus.IUserId[];
+        public static create(properties?: proteus.INewOtrMessage): proteus.NewOtrMessage;
+        public static encode(message: proteus.INewOtrMessage, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.INewOtrMessage, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.NewOtrMessage;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.NewOtrMessage;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.NewOtrMessage;
+        public static toObject(message: proteus.NewOtrMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
+
+    interface IQualifiedNewOtrMessage {
+        sender: proteus.IClientId;
+        recipients?: (proteus.IQualifiedUserEntry[]|null);
+        nativePush?: (boolean|null);
+        blob?: (Uint8Array|null);
+        nativePriority?: (proteus.Priority|null);
+        transient?: (boolean|null);
+        reportAll?: (proteus.ClientMismatchStrategy.IReportAll|null);
+        ignoreAll?: (proteus.ClientMismatchStrategy.IIgnoreAll|null);
+        reportOnly?: (proteus.ClientMismatchStrategy.IReportOnly|null);
+        ignoreOnly?: (proteus.ClientMismatchStrategy.IIgnoreOnly|null);
+    }
+
+    class QualifiedNewOtrMessage implements IQualifiedNewOtrMessage {
+        constructor(properties?: proteus.IQualifiedNewOtrMessage);
+        public sender: proteus.IClientId;
+        public recipients: proteus.IQualifiedUserEntry[];
+        public nativePush: boolean;
+        public blob: Uint8Array;
+        public nativePriority: proteus.Priority;
+        public transient: boolean;
+        public reportAll?: (proteus.ClientMismatchStrategy.IReportAll|null);
+        public ignoreAll?: (proteus.ClientMismatchStrategy.IIgnoreAll|null);
+        public reportOnly?: (proteus.ClientMismatchStrategy.IReportOnly|null);
+        public ignoreOnly?: (proteus.ClientMismatchStrategy.IIgnoreOnly|null);
+        public clientMismatchStrategy?: ("reportAll"|"ignoreAll"|"reportOnly"|"ignoreOnly");
+        public static create(properties?: proteus.IQualifiedNewOtrMessage): proteus.QualifiedNewOtrMessage;
+        public static encode(message: proteus.IQualifiedNewOtrMessage, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IQualifiedNewOtrMessage, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.QualifiedNewOtrMessage;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.QualifiedNewOtrMessage;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.QualifiedNewOtrMessage;
+        public static toObject(message: proteus.QualifiedNewOtrMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
+
+    interface IClientMismatchStrategy {
+    }
+
+    class ClientMismatchStrategy implements IClientMismatchStrategy {
+        constructor(properties?: proteus.IClientMismatchStrategy);
+        public static create(properties?: proteus.IClientMismatchStrategy): proteus.ClientMismatchStrategy;
+        public static encode(message: proteus.IClientMismatchStrategy, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IClientMismatchStrategy, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.ClientMismatchStrategy;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.ClientMismatchStrategy;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.ClientMismatchStrategy;
+        public static toObject(message: proteus.ClientMismatchStrategy, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
+
+    namespace ClientMismatchStrategy {
 
-export class OtrAssetMeta implements IOtrAssetMeta {
-    constructor(properties?: IOtrAssetMeta);
-    public sender: IClientId;
-    public recipients: IUserEntry[];
-    public isInline: boolean;
-    public nativePush: boolean;
-    public static create(properties?: IOtrAssetMeta): OtrAssetMeta;
-    public static encode(message: IOtrAssetMeta, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static encodeDelimited(message: IOtrAssetMeta, writer?: $protobuf.Writer): $protobuf.Writer;
-    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): OtrAssetMeta;
-    public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): OtrAssetMeta;
-    public static verify(message: { [k: string]: any }): (string|null);
-    public static fromObject(object: { [k: string]: any }): OtrAssetMeta;
-    public static toObject(message: OtrAssetMeta, options?: $protobuf.IConversionOptions): { [k: string]: any };
-    public toJSON(): { [k: string]: any };
+        interface IReportAll {
+        }
+
+        class ReportAll implements IReportAll {
+            constructor(properties?: proteus.ClientMismatchStrategy.IReportAll);
+            public static create(properties?: proteus.ClientMismatchStrategy.IReportAll): proteus.ClientMismatchStrategy.ReportAll;
+            public static encode(message: proteus.ClientMismatchStrategy.IReportAll, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static encodeDelimited(message: proteus.ClientMismatchStrategy.IReportAll, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.ClientMismatchStrategy.ReportAll;
+            public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.ClientMismatchStrategy.ReportAll;
+            public static verify(message: { [k: string]: any }): (string|null);
+            public static fromObject(object: { [k: string]: any }): proteus.ClientMismatchStrategy.ReportAll;
+            public static toObject(message: proteus.ClientMismatchStrategy.ReportAll, options?: $protobuf.IConversionOptions): { [k: string]: any };
+            public toJSON(): { [k: string]: any };
+        }
+
+        interface IIgnoreAll {
+        }
+
+        class IgnoreAll implements IIgnoreAll {
+            constructor(properties?: proteus.ClientMismatchStrategy.IIgnoreAll);
+            public static create(properties?: proteus.ClientMismatchStrategy.IIgnoreAll): proteus.ClientMismatchStrategy.IgnoreAll;
+            public static encode(message: proteus.ClientMismatchStrategy.IIgnoreAll, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static encodeDelimited(message: proteus.ClientMismatchStrategy.IIgnoreAll, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.ClientMismatchStrategy.IgnoreAll;
+            public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.ClientMismatchStrategy.IgnoreAll;
+            public static verify(message: { [k: string]: any }): (string|null);
+            public static fromObject(object: { [k: string]: any }): proteus.ClientMismatchStrategy.IgnoreAll;
+            public static toObject(message: proteus.ClientMismatchStrategy.IgnoreAll, options?: $protobuf.IConversionOptions): { [k: string]: any };
+            public toJSON(): { [k: string]: any };
+        }
+
+        interface IReportOnly {
+            userIds?: (proteus.IQualifiedUserId[]|null);
+        }
+
+        class ReportOnly implements IReportOnly {
+            constructor(properties?: proteus.ClientMismatchStrategy.IReportOnly);
+            public userIds: proteus.IQualifiedUserId[];
+            public static create(properties?: proteus.ClientMismatchStrategy.IReportOnly): proteus.ClientMismatchStrategy.ReportOnly;
+            public static encode(message: proteus.ClientMismatchStrategy.IReportOnly, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static encodeDelimited(message: proteus.ClientMismatchStrategy.IReportOnly, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.ClientMismatchStrategy.ReportOnly;
+            public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.ClientMismatchStrategy.ReportOnly;
+            public static verify(message: { [k: string]: any }): (string|null);
+            public static fromObject(object: { [k: string]: any }): proteus.ClientMismatchStrategy.ReportOnly;
+            public static toObject(message: proteus.ClientMismatchStrategy.ReportOnly, options?: $protobuf.IConversionOptions): { [k: string]: any };
+            public toJSON(): { [k: string]: any };
+        }
+
+        interface IIgnoreOnly {
+            userIds?: (proteus.IQualifiedUserId[]|null);
+        }
+
+        class IgnoreOnly implements IIgnoreOnly {
+            constructor(properties?: proteus.ClientMismatchStrategy.IIgnoreOnly);
+            public userIds: proteus.IQualifiedUserId[];
+            public static create(properties?: proteus.ClientMismatchStrategy.IIgnoreOnly): proteus.ClientMismatchStrategy.IgnoreOnly;
+            public static encode(message: proteus.ClientMismatchStrategy.IIgnoreOnly, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static encodeDelimited(message: proteus.ClientMismatchStrategy.IIgnoreOnly, writer?: $protobuf.Writer): $protobuf.Writer;
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.ClientMismatchStrategy.IgnoreOnly;
+            public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.ClientMismatchStrategy.IgnoreOnly;
+            public static verify(message: { [k: string]: any }): (string|null);
+            public static fromObject(object: { [k: string]: any }): proteus.ClientMismatchStrategy.IgnoreOnly;
+            public static toObject(message: proteus.ClientMismatchStrategy.IgnoreOnly, options?: $protobuf.IConversionOptions): { [k: string]: any };
+            public toJSON(): { [k: string]: any };
+        }
+    }
+
+    interface IOtrAssetMeta {
+        sender: proteus.IClientId;
+        recipients?: (proteus.IUserEntry[]|null);
+        isInline?: (boolean|null);
+        nativePush?: (boolean|null);
+    }
+
+    class OtrAssetMeta implements IOtrAssetMeta {
+        constructor(properties?: proteus.IOtrAssetMeta);
+        public sender: proteus.IClientId;
+        public recipients: proteus.IUserEntry[];
+        public isInline: boolean;
+        public nativePush: boolean;
+        public static create(properties?: proteus.IOtrAssetMeta): proteus.OtrAssetMeta;
+        public static encode(message: proteus.IOtrAssetMeta, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static encodeDelimited(message: proteus.IOtrAssetMeta, writer?: $protobuf.Writer): $protobuf.Writer;
+        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): proteus.OtrAssetMeta;
+        public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): proteus.OtrAssetMeta;
+        public static verify(message: { [k: string]: any }): (string|null);
+        public static fromObject(object: { [k: string]: any }): proteus.OtrAssetMeta;
+        public static toObject(message: proteus.OtrAssetMeta, options?: $protobuf.IConversionOptions): { [k: string]: any };
+        public toJSON(): { [k: string]: any };
+    }
 }