@ondewo/csi-client-angular 3.2.1 → 5.0.0

package/esm2022/api/ondewo/nlu/common.pb.mjs

@@ -1,9 +1,61 @@
 import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf000 from '@ngx-grpc/well-known-types';
+import * as googleProtobuf001 from '@ngx-grpc/well-known-types';
 export var SortingMode;
 (function (SortingMode) {
     SortingMode[SortingMode["ASCENDING"] = 0] = "ASCENDING";
     SortingMode[SortingMode["DESCENDING"] = 1] = "DESCENDING";
 })(SortingMode || (SortingMode = {}));
+export var NotificationFlaggedStatus;
+(function (NotificationFlaggedStatus) {
+    NotificationFlaggedStatus[NotificationFlaggedStatus["NOTIFICATION_FLAGGED_STATUS_UNSPECIFIED"] = 0] = "NOTIFICATION_FLAGGED_STATUS_UNSPECIFIED";
+    NotificationFlaggedStatus[NotificationFlaggedStatus["NOTIFICATION_FLAGGED_STATUS_FLAGGED"] = 1] = "NOTIFICATION_FLAGGED_STATUS_FLAGGED";
+    NotificationFlaggedStatus[NotificationFlaggedStatus["NOTIFICATION_FLAGGED_STATUS_UNFLAGGED"] = 2] = "NOTIFICATION_FLAGGED_STATUS_UNFLAGGED";
+})(NotificationFlaggedStatus || (NotificationFlaggedStatus = {}));
+export var NotificationReadStatus;
+(function (NotificationReadStatus) {
+    NotificationReadStatus[NotificationReadStatus["NOTIFICATION_READ_STATUS_UNSPECIFIED"] = 0] = "NOTIFICATION_READ_STATUS_UNSPECIFIED";
+    NotificationReadStatus[NotificationReadStatus["NOTIFICATION_READ_STATUS_READ"] = 1] = "NOTIFICATION_READ_STATUS_READ";
+    NotificationReadStatus[NotificationReadStatus["NOTIFICATION_READ_STATUS_UNREAD"] = 2] = "NOTIFICATION_READ_STATUS_UNREAD";
+})(NotificationReadStatus || (NotificationReadStatus = {}));
+export var NotificationVisibility;
+(function (NotificationVisibility) {
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_UNSPECIFIED"] = 0] = "NOTIFICATION_VISIBILITY_UNSPECIFIED";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_USER"] = 1] = "NOTIFICATION_VISIBILITY_USER";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_PROJECT"] = 2] = "NOTIFICATION_VISIBILITY_PROJECT";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_PROJECT_OWNER"] = 3] = "NOTIFICATION_VISIBILITY_PROJECT_OWNER";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_PROJECT_ADMIN"] = 4] = "NOTIFICATION_VISIBILITY_PROJECT_ADMIN";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_PROJECT_DEVELOPER"] = 5] = "NOTIFICATION_VISIBILITY_PROJECT_DEVELOPER";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_PROJECT_USER"] = 6] = "NOTIFICATION_VISIBILITY_PROJECT_USER";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_PROJECT_EXECUTOR"] = 7] = "NOTIFICATION_VISIBILITY_PROJECT_EXECUTOR";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_PROJECT_INACTIVE"] = 8] = "NOTIFICATION_VISIBILITY_PROJECT_INACTIVE";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_SERVER_ADMIN"] = 9] = "NOTIFICATION_VISIBILITY_SERVER_ADMIN";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_SERVER_MANAGER"] = 10] = "NOTIFICATION_VISIBILITY_SERVER_MANAGER";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_SERVER_USER"] = 11] = "NOTIFICATION_VISIBILITY_SERVER_USER";
+    NotificationVisibility[NotificationVisibility["NOTIFICATION_VISIBILITY_SERVER_INACTIVE"] = 12] = "NOTIFICATION_VISIBILITY_SERVER_INACTIVE";
+})(NotificationVisibility || (NotificationVisibility = {}));
+export var NotificationType;
+(function (NotificationType) {
+    NotificationType[NotificationType["NOTIFICATION_TYPE_UNSPECIFIED"] = 0] = "NOTIFICATION_TYPE_UNSPECIFIED";
+    NotificationType[NotificationType["NOTIFICATION_TYPE_DEBUG"] = 1] = "NOTIFICATION_TYPE_DEBUG";
+    NotificationType[NotificationType["NOTIFICATION_TYPE_WARNING"] = 2] = "NOTIFICATION_TYPE_WARNING";
+    NotificationType[NotificationType["NOTIFICATION_TYPE_INFO"] = 3] = "NOTIFICATION_TYPE_INFO";
+    NotificationType[NotificationType["NOTIFICATION_TYPE_ERROR"] = 4] = "NOTIFICATION_TYPE_ERROR";
+    NotificationType[NotificationType["NOTIFICATION_TYPE_NEWS"] = 5] = "NOTIFICATION_TYPE_NEWS";
+})(NotificationType || (NotificationType = {}));
+export var NotificationOrigin;
+(function (NotificationOrigin) {
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_UNSPECIFIED"] = 0] = "NOTIFICATION_ORIGIN_UNSPECIFIED";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_AIM"] = 1] = "NOTIFICATION_ORIGIN_ONDEWO_AIM";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_BPI"] = 2] = "NOTIFICATION_ORIGIN_ONDEWO_BPI";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_CSI"] = 3] = "NOTIFICATION_ORIGIN_ONDEWO_CSI";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_NLU"] = 4] = "NOTIFICATION_ORIGIN_ONDEWO_NLU";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_S2T"] = 5] = "NOTIFICATION_ORIGIN_ONDEWO_S2T";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_SIP"] = 6] = "NOTIFICATION_ORIGIN_ONDEWO_SIP";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_T2S"] = 7] = "NOTIFICATION_ORIGIN_ONDEWO_T2S";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_VTSI"] = 8] = "NOTIFICATION_ORIGIN_ONDEWO_VTSI";
+    NotificationOrigin[NotificationOrigin["NOTIFICATION_ORIGIN_ONDEWO_VTSI_RABBITMQ"] = 9] = "NOTIFICATION_ORIGIN_ONDEWO_VTSI_RABBITMQ";
+})(NotificationOrigin || (NotificationOrigin = {}));
 /**
  * Message implementation for ondewo.nlu.StatResponse
  */
@@ -105,4 +157,1807 @@ export class StatResponse {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/common.pb.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,iBAAiB,CAAC;AACzE,MAAM,CAAN,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,uDAAa,CAAA;IACb,yDAAc,CAAA;AAChB,CAAC,EAHW,WAAW,KAAX,WAAW,QAGtB;AACD;;GAEG;AACH,MAAM,OAAO,YAAY;aAChB,OAAE,GAAG,yBAAyB,CAAC;IAEtC;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC;QACpC,YAAY,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAuB;QACzC,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAuB,EACvB,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,KAAK,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACvC,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAuB,EACvB,OAAqB;QAErB,IAAI,SAAS,CAAC,KAAK,EAAE;YACnB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;SACzC;IACH,CAAC;IAID;;;OAGG;IACH,YAAY,MAAgD;QAC1D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,KAAa;QACrB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,YAAY,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nexport enum SortingMode {\n  ASCENDING = 0,\n  DESCENDING = 1\n}\n/**\n * Message implementation for ondewo.nlu.StatResponse\n */\nexport class StatResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.StatResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new StatResponse();\n    StatResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: StatResponse) {\n    _instance.value = _instance.value || 0;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: StatResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.value = _reader.readUint32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    StatResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: StatResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.value) {\n      _writer.writeUint32(1, _instance.value);\n    }\n  }\n\n  private _value: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of StatResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<StatResponse.AsObject>) {\n    _value = _value || {};\n    this.value = _value.value;\n    StatResponse.refineValues(this);\n  }\n  get value(): number {\n    return this._value;\n  }\n  set value(value: number) {\n    this._value = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    StatResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): StatResponse.AsObject {\n    return {\n      value: this.value\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): StatResponse.AsProtobufJSON {\n    return {\n      value: this.value\n    };\n  }\n}\nexport module StatResponse {\n  /**\n   * Standard JavaScript object representation for StatResponse\n   */\n  export interface AsObject {\n    value: number;\n  }\n\n  /**\n   * Protobuf JSON representation for StatResponse\n   */\n  export interface AsProtobufJSON {\n    value: number;\n  }\n}\n"]}
+/**
+ * Message implementation for ondewo.nlu.Comment
+ */
+export class Comment {
+    static { this.id = 'ondewo.nlu.Comment'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Comment();
+        Comment.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+        _instance.text = _instance.text || '';
+        _instance.userId = _instance.userId || '';
+        _instance.commentAboutName = _instance.commentAboutName || '';
+        _instance.parentCommentName = _instance.parentCommentName || '';
+        _instance.createdAt = _instance.createdAt || undefined;
+        _instance.modifiedAt = _instance.modifiedAt || undefined;
+        _instance.createdBy = _instance.createdBy || '';
+        _instance.modifiedBy = _instance.modifiedBy || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.name = _reader.readString();
+                    break;
+                case 2:
+                    _instance.text = _reader.readString();
+                    break;
+                case 3:
+                    _instance.userId = _reader.readString();
+                    break;
+                case 4:
+                    _instance.commentAboutName = _reader.readString();
+                    break;
+                case 5:
+                    _instance.parentCommentName = _reader.readString();
+                    break;
+                case 6:
+                    _instance.createdAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.modifiedAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.modifiedAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 8:
+                    _instance.createdBy = _reader.readString();
+                    break;
+                case 9:
+                    _instance.modifiedBy = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Comment.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+        if (_instance.text) {
+            _writer.writeString(2, _instance.text);
+        }
+        if (_instance.userId) {
+            _writer.writeString(3, _instance.userId);
+        }
+        if (_instance.commentAboutName) {
+            _writer.writeString(4, _instance.commentAboutName);
+        }
+        if (_instance.parentCommentName) {
+            _writer.writeString(5, _instance.parentCommentName);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(6, _instance.createdAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.modifiedAt) {
+            _writer.writeMessage(7, _instance.modifiedAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.createdBy) {
+            _writer.writeString(8, _instance.createdBy);
+        }
+        if (_instance.modifiedBy) {
+            _writer.writeString(9, _instance.modifiedBy);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Comment to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.text = _value.text;
+        this.userId = _value.userId;
+        this.commentAboutName = _value.commentAboutName;
+        this.parentCommentName = _value.parentCommentName;
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf001.Timestamp(_value.createdAt)
+            : undefined;
+        this.modifiedAt = _value.modifiedAt
+            ? new googleProtobuf001.Timestamp(_value.modifiedAt)
+            : undefined;
+        this.createdBy = _value.createdBy;
+        this.modifiedBy = _value.modifiedBy;
+        Comment.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get text() {
+        return this._text;
+    }
+    set text(value) {
+        this._text = value;
+    }
+    get userId() {
+        return this._userId;
+    }
+    set userId(value) {
+        this._userId = value;
+    }
+    get commentAboutName() {
+        return this._commentAboutName;
+    }
+    set commentAboutName(value) {
+        this._commentAboutName = value;
+    }
+    get parentCommentName() {
+        return this._parentCommentName;
+    }
+    set parentCommentName(value) {
+        this._parentCommentName = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get modifiedAt() {
+        return this._modifiedAt;
+    }
+    set modifiedAt(value) {
+        this._modifiedAt = value;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    set createdBy(value) {
+        this._createdBy = value;
+    }
+    get modifiedBy() {
+        return this._modifiedBy;
+    }
+    set modifiedBy(value) {
+        this._modifiedBy = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Comment.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            text: this.text,
+            userId: this.userId,
+            commentAboutName: this.commentAboutName,
+            parentCommentName: this.parentCommentName,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined,
+            modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name,
+            text: this.text,
+            userId: this.userId,
+            commentAboutName: this.commentAboutName,
+            parentCommentName: this.parentCommentName,
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,
+            modifiedAt: this.modifiedAt
+                ? this.modifiedAt.toProtobufJSON(options)
+                : null,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.Notification
+ */
+export class Notification {
+    static { this.id = 'ondewo.nlu.Notification'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Notification();
+        Notification.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+        _instance.userName = _instance.userName || '';
+        _instance.title = _instance.title || '';
+        _instance.descriptionShort = _instance.descriptionShort || '';
+        _instance.descriptionLong = _instance.descriptionLong || '';
+        _instance.notificationFlaggedStatus =
+            _instance.notificationFlaggedStatus || 0;
+        _instance.notificationFlaggedTimestamp =
+            _instance.notificationFlaggedTimestamp || undefined;
+        _instance.notificationReadStatus = _instance.notificationReadStatus || 0;
+        _instance.notificationReadTimestamp =
+            _instance.notificationReadTimestamp || undefined;
+        _instance.notificationOrigin = _instance.notificationOrigin || 0;
+        _instance.originName = _instance.originName || '';
+        _instance.originLanguage = _instance.originLanguage || '';
+        _instance.notificationType = _instance.notificationType || 0;
+        _instance.notificationVisibility = _instance.notificationVisibility || 0;
+        _instance.createdAt = _instance.createdAt || undefined;
+        _instance.modifiedAt = _instance.modifiedAt || undefined;
+        _instance.createdBy = _instance.createdBy || '';
+        _instance.modifiedBy = _instance.modifiedBy || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.name = _reader.readString();
+                    break;
+                case 2:
+                    _instance.userName = _reader.readString();
+                    break;
+                case 3:
+                    _instance.title = _reader.readString();
+                    break;
+                case 4:
+                    _instance.descriptionShort = _reader.readString();
+                    break;
+                case 5:
+                    _instance.descriptionLong = _reader.readString();
+                    break;
+                case 6:
+                    _instance.notificationFlaggedStatus = _reader.readEnum();
+                    break;
+                case 7:
+                    _instance.notificationFlaggedTimestamp = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.notificationFlaggedTimestamp, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 8:
+                    _instance.notificationReadStatus = _reader.readEnum();
+                    break;
+                case 9:
+                    _instance.notificationReadTimestamp = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.notificationReadTimestamp, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 10:
+                    _instance.notificationOrigin = _reader.readEnum();
+                    break;
+                case 11:
+                    _instance.originName = _reader.readString();
+                    break;
+                case 12:
+                    _instance.originLanguage = _reader.readString();
+                    break;
+                case 13:
+                    _instance.notificationType = _reader.readEnum();
+                    break;
+                case 14:
+                    _instance.notificationVisibility = _reader.readEnum();
+                    break;
+                case 15:
+                    _instance.createdAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 16:
+                    _instance.modifiedAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.modifiedAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 17:
+                    _instance.createdBy = _reader.readString();
+                    break;
+                case 18:
+                    _instance.modifiedBy = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Notification.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+        if (_instance.userName) {
+            _writer.writeString(2, _instance.userName);
+        }
+        if (_instance.title) {
+            _writer.writeString(3, _instance.title);
+        }
+        if (_instance.descriptionShort) {
+            _writer.writeString(4, _instance.descriptionShort);
+        }
+        if (_instance.descriptionLong) {
+            _writer.writeString(5, _instance.descriptionLong);
+        }
+        if (_instance.notificationFlaggedStatus) {
+            _writer.writeEnum(6, _instance.notificationFlaggedStatus);
+        }
+        if (_instance.notificationFlaggedTimestamp) {
+            _writer.writeMessage(7, _instance.notificationFlaggedTimestamp, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.notificationReadStatus) {
+            _writer.writeEnum(8, _instance.notificationReadStatus);
+        }
+        if (_instance.notificationReadTimestamp) {
+            _writer.writeMessage(9, _instance.notificationReadTimestamp, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.notificationOrigin) {
+            _writer.writeEnum(10, _instance.notificationOrigin);
+        }
+        if (_instance.originName) {
+            _writer.writeString(11, _instance.originName);
+        }
+        if (_instance.originLanguage) {
+            _writer.writeString(12, _instance.originLanguage);
+        }
+        if (_instance.notificationType) {
+            _writer.writeEnum(13, _instance.notificationType);
+        }
+        if (_instance.notificationVisibility) {
+            _writer.writeEnum(14, _instance.notificationVisibility);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(15, _instance.createdAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.modifiedAt) {
+            _writer.writeMessage(16, _instance.modifiedAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.createdBy) {
+            _writer.writeString(17, _instance.createdBy);
+        }
+        if (_instance.modifiedBy) {
+            _writer.writeString(18, _instance.modifiedBy);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Notification to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.userName = _value.userName;
+        this.title = _value.title;
+        this.descriptionShort = _value.descriptionShort;
+        this.descriptionLong = _value.descriptionLong;
+        this.notificationFlaggedStatus = _value.notificationFlaggedStatus;
+        this.notificationFlaggedTimestamp = _value.notificationFlaggedTimestamp
+            ? new googleProtobuf001.Timestamp(_value.notificationFlaggedTimestamp)
+            : undefined;
+        this.notificationReadStatus = _value.notificationReadStatus;
+        this.notificationReadTimestamp = _value.notificationReadTimestamp
+            ? new googleProtobuf001.Timestamp(_value.notificationReadTimestamp)
+            : undefined;
+        this.notificationOrigin = _value.notificationOrigin;
+        this.originName = _value.originName;
+        this.originLanguage = _value.originLanguage;
+        this.notificationType = _value.notificationType;
+        this.notificationVisibility = _value.notificationVisibility;
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf001.Timestamp(_value.createdAt)
+            : undefined;
+        this.modifiedAt = _value.modifiedAt
+            ? new googleProtobuf001.Timestamp(_value.modifiedAt)
+            : undefined;
+        this.createdBy = _value.createdBy;
+        this.modifiedBy = _value.modifiedBy;
+        Notification.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get userName() {
+        return this._userName;
+    }
+    set userName(value) {
+        this._userName = value;
+    }
+    get title() {
+        return this._title;
+    }
+    set title(value) {
+        this._title = value;
+    }
+    get descriptionShort() {
+        return this._descriptionShort;
+    }
+    set descriptionShort(value) {
+        this._descriptionShort = value;
+    }
+    get descriptionLong() {
+        return this._descriptionLong;
+    }
+    set descriptionLong(value) {
+        this._descriptionLong = value;
+    }
+    get notificationFlaggedStatus() {
+        return this._notificationFlaggedStatus;
+    }
+    set notificationFlaggedStatus(value) {
+        this._notificationFlaggedStatus = value;
+    }
+    get notificationFlaggedTimestamp() {
+        return this._notificationFlaggedTimestamp;
+    }
+    set notificationFlaggedTimestamp(value) {
+        this._notificationFlaggedTimestamp = value;
+    }
+    get notificationReadStatus() {
+        return this._notificationReadStatus;
+    }
+    set notificationReadStatus(value) {
+        this._notificationReadStatus = value;
+    }
+    get notificationReadTimestamp() {
+        return this._notificationReadTimestamp;
+    }
+    set notificationReadTimestamp(value) {
+        this._notificationReadTimestamp = value;
+    }
+    get notificationOrigin() {
+        return this._notificationOrigin;
+    }
+    set notificationOrigin(value) {
+        this._notificationOrigin = value;
+    }
+    get originName() {
+        return this._originName;
+    }
+    set originName(value) {
+        this._originName = value;
+    }
+    get originLanguage() {
+        return this._originLanguage;
+    }
+    set originLanguage(value) {
+        this._originLanguage = value;
+    }
+    get notificationType() {
+        return this._notificationType;
+    }
+    set notificationType(value) {
+        this._notificationType = value;
+    }
+    get notificationVisibility() {
+        return this._notificationVisibility;
+    }
+    set notificationVisibility(value) {
+        this._notificationVisibility = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get modifiedAt() {
+        return this._modifiedAt;
+    }
+    set modifiedAt(value) {
+        this._modifiedAt = value;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    set createdBy(value) {
+        this._createdBy = value;
+    }
+    get modifiedBy() {
+        return this._modifiedBy;
+    }
+    set modifiedBy(value) {
+        this._modifiedBy = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Notification.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            userName: this.userName,
+            title: this.title,
+            descriptionShort: this.descriptionShort,
+            descriptionLong: this.descriptionLong,
+            notificationFlaggedStatus: this.notificationFlaggedStatus,
+            notificationFlaggedTimestamp: this.notificationFlaggedTimestamp
+                ? this.notificationFlaggedTimestamp.toObject()
+                : undefined,
+            notificationReadStatus: this.notificationReadStatus,
+            notificationReadTimestamp: this.notificationReadTimestamp
+                ? this.notificationReadTimestamp.toObject()
+                : undefined,
+            notificationOrigin: this.notificationOrigin,
+            originName: this.originName,
+            originLanguage: this.originLanguage,
+            notificationType: this.notificationType,
+            notificationVisibility: this.notificationVisibility,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined,
+            modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name,
+            userName: this.userName,
+            title: this.title,
+            descriptionShort: this.descriptionShort,
+            descriptionLong: this.descriptionLong,
+            notificationFlaggedStatus: NotificationFlaggedStatus[this.notificationFlaggedStatus === null ||
+                this.notificationFlaggedStatus === undefined
+                ? 0
+                : this.notificationFlaggedStatus],
+            notificationFlaggedTimestamp: this.notificationFlaggedTimestamp
+                ? this.notificationFlaggedTimestamp.toProtobufJSON(options)
+                : null,
+            notificationReadStatus: NotificationReadStatus[this.notificationReadStatus === null ||
+                this.notificationReadStatus === undefined
+                ? 0
+                : this.notificationReadStatus],
+            notificationReadTimestamp: this.notificationReadTimestamp
+                ? this.notificationReadTimestamp.toProtobufJSON(options)
+                : null,
+            notificationOrigin: NotificationOrigin[this.notificationOrigin === null ||
+                this.notificationOrigin === undefined
+                ? 0
+                : this.notificationOrigin],
+            originName: this.originName,
+            originLanguage: this.originLanguage,
+            notificationType: NotificationType[this.notificationType === null || this.notificationType === undefined
+                ? 0
+                : this.notificationType],
+            notificationVisibility: NotificationVisibility[this.notificationVisibility === null ||
+                this.notificationVisibility === undefined
+                ? 0
+                : this.notificationVisibility],
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,
+            modifiedAt: this.modifiedAt
+                ? this.modifiedAt.toProtobufJSON(options)
+                : null,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.AddNotificationsRequest
+ */
+export class AddNotificationsRequest {
+    static { this.id = 'ondewo.nlu.AddNotificationsRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new AddNotificationsRequest();
+        AddNotificationsRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.notifications = _instance.notifications || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new Notification();
+                    _reader.readMessage(messageInitializer1, Notification.deserializeBinaryFromReader);
+                    (_instance.notifications = _instance.notifications || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        AddNotificationsRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.notifications && _instance.notifications.length) {
+            _writer.writeRepeatedMessage(1, _instance.notifications, Notification.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of AddNotificationsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.notifications = (_value.notifications || []).map(m => new Notification(m));
+        AddNotificationsRequest.refineValues(this);
+    }
+    get notifications() {
+        return this._notifications;
+    }
+    set notifications(value) {
+        this._notifications = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        AddNotificationsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            notifications: (this.notifications || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            notifications: (this.notifications || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.AddNotificationsResponse
+ */
+export class AddNotificationsResponse {
+    static { this.id = 'ondewo.nlu.AddNotificationsResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new AddNotificationsResponse();
+        AddNotificationsResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.notifications = _instance.notifications || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new Notification();
+                    _reader.readMessage(messageInitializer1, Notification.deserializeBinaryFromReader);
+                    (_instance.notifications = _instance.notifications || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        AddNotificationsResponse.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.notifications && _instance.notifications.length) {
+            _writer.writeRepeatedMessage(1, _instance.notifications, Notification.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of AddNotificationsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.notifications = (_value.notifications || []).map(m => new Notification(m));
+        AddNotificationsResponse.refineValues(this);
+    }
+    get notifications() {
+        return this._notifications;
+    }
+    set notifications(value) {
+        this._notifications = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        AddNotificationsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            notifications: (this.notifications || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            notifications: (this.notifications || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.NotificationFilter
+ */
+export class NotificationFilter {
+    static { this.id = 'ondewo.nlu.NotificationFilter'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new NotificationFilter();
+        NotificationFilter.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.languageCodes = _instance.languageCodes || [];
+        _instance.notificationOrigins = _instance.notificationOrigins || [];
+        _instance.notificationVisibilities =
+            _instance.notificationVisibilities || [];
+        _instance.notificationFlaggedStatus =
+            _instance.notificationFlaggedStatus || [];
+        _instance.notificationReadStatus = _instance.notificationReadStatus || [];
+        _instance.earliest = _instance.earliest || undefined;
+        _instance.latest = _instance.latest || undefined;
+        _instance.userNames = _instance.userNames || [];
+        _instance.originNames = _instance.originNames || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    (_instance.languageCodes = _instance.languageCodes || []).push(_reader.readString());
+                    break;
+                case 2:
+                    (_instance.notificationOrigins =
+                        _instance.notificationOrigins || []).push(...(_reader.readPackedEnum() || []));
+                    break;
+                case 3:
+                    (_instance.notificationVisibilities =
+                        _instance.notificationVisibilities || []).push(...(_reader.readPackedEnum() || []));
+                    break;
+                case 4:
+                    (_instance.notificationFlaggedStatus =
+                        _instance.notificationFlaggedStatus || []).push(...(_reader.readPackedEnum() || []));
+                    break;
+                case 5:
+                    (_instance.notificationReadStatus =
+                        _instance.notificationReadStatus || []).push(...(_reader.readPackedEnum() || []));
+                    break;
+                case 6:
+                    _instance.earliest = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.earliest, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.latest = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.latest, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 8:
+                    (_instance.userNames = _instance.userNames || []).push(_reader.readString());
+                    break;
+                case 9:
+                    (_instance.originNames = _instance.originNames || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        NotificationFilter.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.languageCodes && _instance.languageCodes.length) {
+            _writer.writeRepeatedString(1, _instance.languageCodes);
+        }
+        if (_instance.notificationOrigins && _instance.notificationOrigins.length) {
+            _writer.writePackedEnum(2, _instance.notificationOrigins);
+        }
+        if (_instance.notificationVisibilities &&
+            _instance.notificationVisibilities.length) {
+            _writer.writePackedEnum(3, _instance.notificationVisibilities);
+        }
+        if (_instance.notificationFlaggedStatus &&
+            _instance.notificationFlaggedStatus.length) {
+            _writer.writePackedEnum(4, _instance.notificationFlaggedStatus);
+        }
+        if (_instance.notificationReadStatus &&
+            _instance.notificationReadStatus.length) {
+            _writer.writePackedEnum(5, _instance.notificationReadStatus);
+        }
+        if (_instance.earliest) {
+            _writer.writeMessage(6, _instance.earliest, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.latest) {
+            _writer.writeMessage(7, _instance.latest, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.userNames && _instance.userNames.length) {
+            _writer.writeRepeatedString(8, _instance.userNames);
+        }
+        if (_instance.originNames && _instance.originNames.length) {
+            _writer.writeRepeatedString(9, _instance.originNames);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of NotificationFilter to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.languageCodes = (_value.languageCodes || []).slice();
+        this.notificationOrigins = (_value.notificationOrigins || []).slice();
+        this.notificationVisibilities = (_value.notificationVisibilities || []).slice();
+        this.notificationFlaggedStatus = (_value.notificationFlaggedStatus || []).slice();
+        this.notificationReadStatus = (_value.notificationReadStatus || []).slice();
+        this.earliest = _value.earliest
+            ? new googleProtobuf001.Timestamp(_value.earliest)
+            : undefined;
+        this.latest = _value.latest
+            ? new googleProtobuf001.Timestamp(_value.latest)
+            : undefined;
+        this.userNames = (_value.userNames || []).slice();
+        this.originNames = (_value.originNames || []).slice();
+        NotificationFilter.refineValues(this);
+    }
+    get languageCodes() {
+        return this._languageCodes;
+    }
+    set languageCodes(value) {
+        this._languageCodes = value;
+    }
+    get notificationOrigins() {
+        return this._notificationOrigins;
+    }
+    set notificationOrigins(value) {
+        this._notificationOrigins = value;
+    }
+    get notificationVisibilities() {
+        return this._notificationVisibilities;
+    }
+    set notificationVisibilities(value) {
+        this._notificationVisibilities = value;
+    }
+    get notificationFlaggedStatus() {
+        return this._notificationFlaggedStatus;
+    }
+    set notificationFlaggedStatus(value) {
+        this._notificationFlaggedStatus = value;
+    }
+    get notificationReadStatus() {
+        return this._notificationReadStatus;
+    }
+    set notificationReadStatus(value) {
+        this._notificationReadStatus = value;
+    }
+    get earliest() {
+        return this._earliest;
+    }
+    set earliest(value) {
+        this._earliest = value;
+    }
+    get latest() {
+        return this._latest;
+    }
+    set latest(value) {
+        this._latest = value;
+    }
+    get userNames() {
+        return this._userNames;
+    }
+    set userNames(value) {
+        this._userNames = value;
+    }
+    get originNames() {
+        return this._originNames;
+    }
+    set originNames(value) {
+        this._originNames = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        NotificationFilter.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            languageCodes: (this.languageCodes || []).slice(),
+            notificationOrigins: (this.notificationOrigins || []).slice(),
+            notificationVisibilities: (this.notificationVisibilities || []).slice(),
+            notificationFlaggedStatus: (this.notificationFlaggedStatus || []).slice(),
+            notificationReadStatus: (this.notificationReadStatus || []).slice(),
+            earliest: this.earliest ? this.earliest.toObject() : undefined,
+            latest: this.latest ? this.latest.toObject() : undefined,
+            userNames: (this.userNames || []).slice(),
+            originNames: (this.originNames || []).slice()
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            languageCodes: (this.languageCodes || []).slice(),
+            notificationOrigins: (this.notificationOrigins || []).map(v => NotificationOrigin[v]),
+            notificationVisibilities: (this.notificationVisibilities || []).map(v => NotificationVisibility[v]),
+            notificationFlaggedStatus: (this.notificationFlaggedStatus || []).map(v => NotificationFlaggedStatus[v]),
+            notificationReadStatus: (this.notificationReadStatus || []).map(v => NotificationReadStatus[v]),
+            earliest: this.earliest ? this.earliest.toProtobufJSON(options) : null,
+            latest: this.latest ? this.latest.toProtobufJSON(options) : null,
+            userNames: (this.userNames || []).slice(),
+            originNames: (this.originNames || []).slice()
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.ListNotificationsRequest
+ */
+export class ListNotificationsRequest {
+    static { this.id = 'ondewo.nlu.ListNotificationsRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListNotificationsRequest();
+        ListNotificationsRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.notificationFilter = _instance.notificationFilter || undefined;
+        _instance.pageToken = _instance.pageToken || '';
+        _instance.fieldMask = _instance.fieldMask || undefined;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.notificationFilter = new NotificationFilter();
+                    _reader.readMessage(_instance.notificationFilter, NotificationFilter.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.pageToken = _reader.readString();
+                    break;
+                case 3:
+                    _instance.fieldMask = new googleProtobuf000.FieldMask();
+                    _reader.readMessage(_instance.fieldMask, googleProtobuf000.FieldMask.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListNotificationsRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.notificationFilter) {
+            _writer.writeMessage(1, _instance.notificationFilter, NotificationFilter.serializeBinaryToWriter);
+        }
+        if (_instance.pageToken) {
+            _writer.writeString(2, _instance.pageToken);
+        }
+        if (_instance.fieldMask) {
+            _writer.writeMessage(3, _instance.fieldMask, googleProtobuf000.FieldMask.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListNotificationsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.notificationFilter = _value.notificationFilter
+            ? new NotificationFilter(_value.notificationFilter)
+            : undefined;
+        this.pageToken = _value.pageToken;
+        this.fieldMask = _value.fieldMask
+            ? new googleProtobuf000.FieldMask(_value.fieldMask)
+            : undefined;
+        ListNotificationsRequest.refineValues(this);
+    }
+    get notificationFilter() {
+        return this._notificationFilter;
+    }
+    set notificationFilter(value) {
+        this._notificationFilter = value;
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    get fieldMask() {
+        return this._fieldMask;
+    }
+    set fieldMask(value) {
+        this._fieldMask = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListNotificationsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            notificationFilter: this.notificationFilter
+                ? this.notificationFilter.toObject()
+                : undefined,
+            pageToken: this.pageToken,
+            fieldMask: this.fieldMask ? this.fieldMask.toObject() : undefined
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            notificationFilter: this.notificationFilter
+                ? this.notificationFilter.toProtobufJSON(options)
+                : null,
+            pageToken: this.pageToken,
+            fieldMask: this.fieldMask ? this.fieldMask.toProtobufJSON(options) : null
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.ListNotificationsResponse
+ */
+export class ListNotificationsResponse {
+    static { this.id = 'ondewo.nlu.ListNotificationsResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListNotificationsResponse();
+        ListNotificationsResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.notifications = _instance.notifications || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new Notification();
+                    _reader.readMessage(messageInitializer1, Notification.deserializeBinaryFromReader);
+                    (_instance.notifications = _instance.notifications || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListNotificationsResponse.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.notifications && _instance.notifications.length) {
+            _writer.writeRepeatedMessage(1, _instance.notifications, Notification.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListNotificationsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.notifications = (_value.notifications || []).map(m => new Notification(m));
+        ListNotificationsResponse.refineValues(this);
+    }
+    get notifications() {
+        return this._notifications;
+    }
+    set notifications(value) {
+        this._notifications = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListNotificationsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            notifications: (this.notifications || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            notifications: (this.notifications || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.SetNotificationsFlaggedStatusRequest
+ */
+export class SetNotificationsFlaggedStatusRequest {
+    static { this.id = 'ondewo.nlu.SetNotificationsFlaggedStatusRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SetNotificationsFlaggedStatusRequest();
+        SetNotificationsFlaggedStatusRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.notificationNames = _instance.notificationNames || [];
+        _instance.flagged = _instance.flagged || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    (_instance.notificationNames =
+                        _instance.notificationNames || []).push(_reader.readString());
+                    break;
+                case 2:
+                    (_instance.flagged = _instance.flagged || []).push(...(_reader.readPackedBool() || []));
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SetNotificationsFlaggedStatusRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.notificationNames && _instance.notificationNames.length) {
+            _writer.writeRepeatedString(1, _instance.notificationNames);
+        }
+        if (_instance.flagged && _instance.flagged.length) {
+            _writer.writePackedBool(2, _instance.flagged);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SetNotificationsFlaggedStatusRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.notificationNames = (_value.notificationNames || []).slice();
+        this.flagged = (_value.flagged || []).slice();
+        SetNotificationsFlaggedStatusRequest.refineValues(this);
+    }
+    get notificationNames() {
+        return this._notificationNames;
+    }
+    set notificationNames(value) {
+        this._notificationNames = value;
+    }
+    get flagged() {
+        return this._flagged;
+    }
+    set flagged(value) {
+        this._flagged = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SetNotificationsFlaggedStatusRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            notificationNames: (this.notificationNames || []).slice(),
+            flagged: (this.flagged || []).slice()
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            notificationNames: (this.notificationNames || []).slice(),
+            flagged: (this.flagged || []).slice()
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.SetNotificationsReadStatusRequest
+ */
+export class SetNotificationsReadStatusRequest {
+    static { this.id = 'ondewo.nlu.SetNotificationsReadStatusRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SetNotificationsReadStatusRequest();
+        SetNotificationsReadStatusRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.notificationNames = _instance.notificationNames || [];
+        _instance.flagged = _instance.flagged || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    (_instance.notificationNames =
+                        _instance.notificationNames || []).push(_reader.readString());
+                    break;
+                case 2:
+                    (_instance.flagged = _instance.flagged || []).push(...(_reader.readPackedBool() || []));
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SetNotificationsReadStatusRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.notificationNames && _instance.notificationNames.length) {
+            _writer.writeRepeatedString(1, _instance.notificationNames);
+        }
+        if (_instance.flagged && _instance.flagged.length) {
+            _writer.writePackedBool(2, _instance.flagged);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SetNotificationsReadStatusRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.notificationNames = (_value.notificationNames || []).slice();
+        this.flagged = (_value.flagged || []).slice();
+        SetNotificationsReadStatusRequest.refineValues(this);
+    }
+    get notificationNames() {
+        return this._notificationNames;
+    }
+    set notificationNames(value) {
+        this._notificationNames = value;
+    }
+    get flagged() {
+        return this._flagged;
+    }
+    set flagged(value) {
+        this._flagged = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SetNotificationsReadStatusRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            notificationNames: (this.notificationNames || []).slice(),
+            flagged: (this.flagged || []).slice()
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            notificationNames: (this.notificationNames || []).slice(),
+            flagged: (this.flagged || []).slice()
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.KeyValuePair
+ */
+export class KeyValuePair {
+    static { this.id = 'ondewo.nlu.KeyValuePair'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new KeyValuePair();
+        KeyValuePair.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.key = _instance.key || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.key = _reader.readString();
+                    break;
+                case 2:
+                    _instance.intValue = _reader.readInt32();
+                    break;
+                case 3:
+                    _instance.floatValue = _reader.readFloat();
+                    break;
+                case 4:
+                    _instance.doubleValue = _reader.readDouble();
+                    break;
+                case 5:
+                    _instance.stringValue = _reader.readString();
+                    break;
+                case 6:
+                    _instance.createdAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        KeyValuePair.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.key) {
+            _writer.writeString(1, _instance.key);
+        }
+        if (_instance.intValue || _instance.intValue === 0) {
+            _writer.writeInt32(2, _instance.intValue);
+        }
+        if (_instance.floatValue || _instance.floatValue === 0) {
+            _writer.writeFloat(3, _instance.floatValue);
+        }
+        if (_instance.doubleValue || _instance.doubleValue === 0) {
+            _writer.writeDouble(4, _instance.doubleValue);
+        }
+        if (_instance.stringValue || _instance.stringValue === '') {
+            _writer.writeString(5, _instance.stringValue);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(6, _instance.createdAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of KeyValuePair to deeply clone from
+     */
+    constructor(_value) {
+        this._value = KeyValuePair.ValueCase.none;
+        _value = _value || {};
+        this.key = _value.key;
+        this.intValue = _value.intValue;
+        this.floatValue = _value.floatValue;
+        this.doubleValue = _value.doubleValue;
+        this.stringValue = _value.stringValue;
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf001.Timestamp(_value.createdAt)
+            : undefined;
+        KeyValuePair.refineValues(this);
+    }
+    get key() {
+        return this._key;
+    }
+    set key(value) {
+        this._key = value;
+    }
+    get intValue() {
+        return this._intValue;
+    }
+    set intValue(value) {
+        if (value !== undefined && value !== null) {
+            this._floatValue = this._doubleValue = this._stringValue = this._createdAt = undefined;
+            this._value = KeyValuePair.ValueCase.intValue;
+        }
+        this._intValue = value;
+    }
+    get floatValue() {
+        return this._floatValue;
+    }
+    set floatValue(value) {
+        if (value !== undefined && value !== null) {
+            this._intValue = this._doubleValue = this._stringValue = this._createdAt = undefined;
+            this._value = KeyValuePair.ValueCase.floatValue;
+        }
+        this._floatValue = value;
+    }
+    get doubleValue() {
+        return this._doubleValue;
+    }
+    set doubleValue(value) {
+        if (value !== undefined && value !== null) {
+            this._intValue = this._floatValue = this._stringValue = this._createdAt = undefined;
+            this._value = KeyValuePair.ValueCase.doubleValue;
+        }
+        this._doubleValue = value;
+    }
+    get stringValue() {
+        return this._stringValue;
+    }
+    set stringValue(value) {
+        if (value !== undefined && value !== null) {
+            this._intValue = this._floatValue = this._doubleValue = this._createdAt = undefined;
+            this._value = KeyValuePair.ValueCase.stringValue;
+        }
+        this._stringValue = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        if (value !== undefined && value !== null) {
+            this._intValue = this._floatValue = this._doubleValue = this._stringValue = undefined;
+            this._value = KeyValuePair.ValueCase.createdAt;
+        }
+        this._createdAt = value;
+    }
+    get value() {
+        return this._value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        KeyValuePair.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            key: this.key,
+            intValue: this.intValue,
+            floatValue: this.floatValue,
+            doubleValue: this.doubleValue,
+            stringValue: this.stringValue,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            key: this.key,
+            intValue: this.intValue === null || this.intValue === undefined
+                ? null
+                : this.intValue,
+            floatValue: this.floatValue === null || this.floatValue === undefined
+                ? null
+                : this.floatValue,
+            doubleValue: this.doubleValue === null || this.doubleValue === undefined
+                ? null
+                : this.doubleValue,
+            stringValue: this.stringValue === null || this.stringValue === undefined
+                ? null
+                : this.stringValue,
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null
+        };
+    }
+}
+(function (KeyValuePair) {
+    let ValueCase;
+    (function (ValueCase) {
+        ValueCase[ValueCase["none"] = 0] = "none";
+        ValueCase[ValueCase["intValue"] = 1] = "intValue";
+        ValueCase[ValueCase["floatValue"] = 2] = "floatValue";
+        ValueCase[ValueCase["doubleValue"] = 3] = "doubleValue";
+        ValueCase[ValueCase["stringValue"] = 4] = "stringValue";
+        ValueCase[ValueCase["createdAt"] = 5] = "createdAt";
+    })(ValueCase = KeyValuePair.ValueCase || (KeyValuePair.ValueCase = {}));
+})(KeyValuePair || (KeyValuePair = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/common.pb.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleProtobuf000 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf001 from '@ngx-grpc/well-known-types';\nexport enum SortingMode {\n  ASCENDING = 0,\n  DESCENDING = 1\n}\nexport enum NotificationFlaggedStatus {\n  NOTIFICATION_FLAGGED_STATUS_UNSPECIFIED = 0,\n  NOTIFICATION_FLAGGED_STATUS_FLAGGED = 1,\n  NOTIFICATION_FLAGGED_STATUS_UNFLAGGED = 2\n}\nexport enum NotificationReadStatus {\n  NOTIFICATION_READ_STATUS_UNSPECIFIED = 0,\n  NOTIFICATION_READ_STATUS_READ = 1,\n  NOTIFICATION_READ_STATUS_UNREAD = 2\n}\nexport enum NotificationVisibility {\n  NOTIFICATION_VISIBILITY_UNSPECIFIED = 0,\n  NOTIFICATION_VISIBILITY_USER = 1,\n  NOTIFICATION_VISIBILITY_PROJECT = 2,\n  NOTIFICATION_VISIBILITY_PROJECT_OWNER = 3,\n  NOTIFICATION_VISIBILITY_PROJECT_ADMIN = 4,\n  NOTIFICATION_VISIBILITY_PROJECT_DEVELOPER = 5,\n  NOTIFICATION_VISIBILITY_PROJECT_USER = 6,\n  NOTIFICATION_VISIBILITY_PROJECT_EXECUTOR = 7,\n  NOTIFICATION_VISIBILITY_PROJECT_INACTIVE = 8,\n  NOTIFICATION_VISIBILITY_SERVER_ADMIN = 9,\n  NOTIFICATION_VISIBILITY_SERVER_MANAGER = 10,\n  NOTIFICATION_VISIBILITY_SERVER_USER = 11,\n  NOTIFICATION_VISIBILITY_SERVER_INACTIVE = 12\n}\nexport enum NotificationType {\n  NOTIFICATION_TYPE_UNSPECIFIED = 0,\n  NOTIFICATION_TYPE_DEBUG = 1,\n  NOTIFICATION_TYPE_WARNING = 2,\n  NOTIFICATION_TYPE_INFO = 3,\n  NOTIFICATION_TYPE_ERROR = 4,\n  NOTIFICATION_TYPE_NEWS = 5\n}\nexport enum NotificationOrigin {\n  NOTIFICATION_ORIGIN_UNSPECIFIED = 0,\n  NOTIFICATION_ORIGIN_ONDEWO_AIM = 1,\n  NOTIFICATION_ORIGIN_ONDEWO_BPI = 2,\n  NOTIFICATION_ORIGIN_ONDEWO_CSI = 3,\n  NOTIFICATION_ORIGIN_ONDEWO_NLU = 4,\n  NOTIFICATION_ORIGIN_ONDEWO_S2T = 5,\n  NOTIFICATION_ORIGIN_ONDEWO_SIP = 6,\n  NOTIFICATION_ORIGIN_ONDEWO_T2S = 7,\n  NOTIFICATION_ORIGIN_ONDEWO_VTSI = 8,\n  NOTIFICATION_ORIGIN_ONDEWO_VTSI_RABBITMQ = 9\n}\n/**\n * Message implementation for ondewo.nlu.StatResponse\n */\nexport class StatResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.StatResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new StatResponse();\n    StatResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: StatResponse) {\n    _instance.value = _instance.value || 0;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: StatResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.value = _reader.readUint32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    StatResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: StatResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.value) {\n      _writer.writeUint32(1, _instance.value);\n    }\n  }\n\n  private _value: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of StatResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<StatResponse.AsObject>) {\n    _value = _value || {};\n    this.value = _value.value;\n    StatResponse.refineValues(this);\n  }\n  get value(): number {\n    return this._value;\n  }\n  set value(value: number) {\n    this._value = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    StatResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): StatResponse.AsObject {\n    return {\n      value: this.value\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): StatResponse.AsProtobufJSON {\n    return {\n      value: this.value\n    };\n  }\n}\nexport module StatResponse {\n  /**\n   * Standard JavaScript object representation for StatResponse\n   */\n  export interface AsObject {\n    value: number;\n  }\n\n  /**\n   * Protobuf JSON representation for StatResponse\n   */\n  export interface AsProtobufJSON {\n    value: number;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.Comment\n */\nexport class Comment implements GrpcMessage {\n  static id = 'ondewo.nlu.Comment';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Comment();\n    Comment.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: Comment) {\n    _instance.name = _instance.name || '';\n    _instance.text = _instance.text || '';\n    _instance.userId = _instance.userId || '';\n    _instance.commentAboutName = _instance.commentAboutName || '';\n    _instance.parentCommentName = _instance.parentCommentName || '';\n    _instance.createdAt = _instance.createdAt || undefined;\n    _instance.modifiedAt = _instance.modifiedAt || undefined;\n    _instance.createdBy = _instance.createdBy || '';\n    _instance.modifiedBy = _instance.modifiedBy || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: Comment,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        case 2:\n          _instance.text = _reader.readString();\n          break;\n        case 3:\n          _instance.userId = _reader.readString();\n          break;\n        case 4:\n          _instance.commentAboutName = _reader.readString();\n          break;\n        case 5:\n          _instance.parentCommentName = _reader.readString();\n          break;\n        case 6:\n          _instance.createdAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.modifiedAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.modifiedAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 8:\n          _instance.createdBy = _reader.readString();\n          break;\n        case 9:\n          _instance.modifiedBy = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Comment.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(_instance: Comment, _writer: BinaryWriter) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.text) {\n      _writer.writeString(2, _instance.text);\n    }\n    if (_instance.userId) {\n      _writer.writeString(3, _instance.userId);\n    }\n    if (_instance.commentAboutName) {\n      _writer.writeString(4, _instance.commentAboutName);\n    }\n    if (_instance.parentCommentName) {\n      _writer.writeString(5, _instance.parentCommentName);\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        6,\n        _instance.createdAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.modifiedAt) {\n      _writer.writeMessage(\n        7,\n        _instance.modifiedAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.createdBy) {\n      _writer.writeString(8, _instance.createdBy);\n    }\n    if (_instance.modifiedBy) {\n      _writer.writeString(9, _instance.modifiedBy);\n    }\n  }\n\n  private _name: string;\n  private _text: string;\n  private _userId: string;\n  private _commentAboutName: string;\n  private _parentCommentName: string;\n  private _createdAt?: googleProtobuf001.Timestamp;\n  private _modifiedAt?: googleProtobuf001.Timestamp;\n  private _createdBy: string;\n  private _modifiedBy: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of Comment to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Comment.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.text = _value.text;\n    this.userId = _value.userId;\n    this.commentAboutName = _value.commentAboutName;\n    this.parentCommentName = _value.parentCommentName;\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf001.Timestamp(_value.createdAt)\n      : undefined;\n    this.modifiedAt = _value.modifiedAt\n      ? new googleProtobuf001.Timestamp(_value.modifiedAt)\n      : undefined;\n    this.createdBy = _value.createdBy;\n    this.modifiedBy = _value.modifiedBy;\n    Comment.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get text(): string {\n    return this._text;\n  }\n  set text(value: string) {\n    this._text = value;\n  }\n  get userId(): string {\n    return this._userId;\n  }\n  set userId(value: string) {\n    this._userId = value;\n  }\n  get commentAboutName(): string {\n    return this._commentAboutName;\n  }\n  set commentAboutName(value: string) {\n    this._commentAboutName = value;\n  }\n  get parentCommentName(): string {\n    return this._parentCommentName;\n  }\n  set parentCommentName(value: string) {\n    this._parentCommentName = value;\n  }\n  get createdAt(): googleProtobuf001.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._createdAt = value;\n  }\n  get modifiedAt(): googleProtobuf001.Timestamp | undefined {\n    return this._modifiedAt;\n  }\n  set modifiedAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._modifiedAt = value;\n  }\n  get createdBy(): string {\n    return this._createdBy;\n  }\n  set createdBy(value: string) {\n    this._createdBy = value;\n  }\n  get modifiedBy(): string {\n    return this._modifiedBy;\n  }\n  set modifiedBy(value: string) {\n    this._modifiedBy = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Comment.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): Comment.AsObject {\n    return {\n      name: this.name,\n      text: this.text,\n      userId: this.userId,\n      commentAboutName: this.commentAboutName,\n      parentCommentName: this.parentCommentName,\n      createdAt: this.createdAt ? this.createdAt.toObject() : undefined,\n      modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): Comment.AsProtobufJSON {\n    return {\n      name: this.name,\n      text: this.text,\n      userId: this.userId,\n      commentAboutName: this.commentAboutName,\n      parentCommentName: this.parentCommentName,\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,\n      modifiedAt: this.modifiedAt\n        ? this.modifiedAt.toProtobufJSON(options)\n        : null,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy\n    };\n  }\n}\nexport module Comment {\n  /**\n   * Standard JavaScript object representation for Comment\n   */\n  export interface AsObject {\n    name: string;\n    text: string;\n    userId: string;\n    commentAboutName: string;\n    parentCommentName: string;\n    createdAt?: googleProtobuf001.Timestamp.AsObject;\n    modifiedAt?: googleProtobuf001.Timestamp.AsObject;\n    createdBy: string;\n    modifiedBy: string;\n  }\n\n  /**\n   * Protobuf JSON representation for Comment\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    text: string;\n    userId: string;\n    commentAboutName: string;\n    parentCommentName: string;\n    createdAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    modifiedAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    createdBy: string;\n    modifiedBy: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.Notification\n */\nexport class Notification implements GrpcMessage {\n  static id = 'ondewo.nlu.Notification';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Notification();\n    Notification.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: Notification) {\n    _instance.name = _instance.name || '';\n    _instance.userName = _instance.userName || '';\n    _instance.title = _instance.title || '';\n    _instance.descriptionShort = _instance.descriptionShort || '';\n    _instance.descriptionLong = _instance.descriptionLong || '';\n    _instance.notificationFlaggedStatus =\n      _instance.notificationFlaggedStatus || 0;\n    _instance.notificationFlaggedTimestamp =\n      _instance.notificationFlaggedTimestamp || undefined;\n    _instance.notificationReadStatus = _instance.notificationReadStatus || 0;\n    _instance.notificationReadTimestamp =\n      _instance.notificationReadTimestamp || undefined;\n    _instance.notificationOrigin = _instance.notificationOrigin || 0;\n    _instance.originName = _instance.originName || '';\n    _instance.originLanguage = _instance.originLanguage || '';\n    _instance.notificationType = _instance.notificationType || 0;\n    _instance.notificationVisibility = _instance.notificationVisibility || 0;\n    _instance.createdAt = _instance.createdAt || undefined;\n    _instance.modifiedAt = _instance.modifiedAt || undefined;\n    _instance.createdBy = _instance.createdBy || '';\n    _instance.modifiedBy = _instance.modifiedBy || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: Notification,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        case 2:\n          _instance.userName = _reader.readString();\n          break;\n        case 3:\n          _instance.title = _reader.readString();\n          break;\n        case 4:\n          _instance.descriptionShort = _reader.readString();\n          break;\n        case 5:\n          _instance.descriptionLong = _reader.readString();\n          break;\n        case 6:\n          _instance.notificationFlaggedStatus = _reader.readEnum();\n          break;\n        case 7:\n          _instance.notificationFlaggedTimestamp = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.notificationFlaggedTimestamp,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 8:\n          _instance.notificationReadStatus = _reader.readEnum();\n          break;\n        case 9:\n          _instance.notificationReadTimestamp = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.notificationReadTimestamp,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 10:\n          _instance.notificationOrigin = _reader.readEnum();\n          break;\n        case 11:\n          _instance.originName = _reader.readString();\n          break;\n        case 12:\n          _instance.originLanguage = _reader.readString();\n          break;\n        case 13:\n          _instance.notificationType = _reader.readEnum();\n          break;\n        case 14:\n          _instance.notificationVisibility = _reader.readEnum();\n          break;\n        case 15:\n          _instance.createdAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 16:\n          _instance.modifiedAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.modifiedAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 17:\n          _instance.createdBy = _reader.readString();\n          break;\n        case 18:\n          _instance.modifiedBy = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Notification.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: Notification,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.userName) {\n      _writer.writeString(2, _instance.userName);\n    }\n    if (_instance.title) {\n      _writer.writeString(3, _instance.title);\n    }\n    if (_instance.descriptionShort) {\n      _writer.writeString(4, _instance.descriptionShort);\n    }\n    if (_instance.descriptionLong) {\n      _writer.writeString(5, _instance.descriptionLong);\n    }\n    if (_instance.notificationFlaggedStatus) {\n      _writer.writeEnum(6, _instance.notificationFlaggedStatus);\n    }\n    if (_instance.notificationFlaggedTimestamp) {\n      _writer.writeMessage(\n        7,\n        _instance.notificationFlaggedTimestamp as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.notificationReadStatus) {\n      _writer.writeEnum(8, _instance.notificationReadStatus);\n    }\n    if (_instance.notificationReadTimestamp) {\n      _writer.writeMessage(\n        9,\n        _instance.notificationReadTimestamp as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.notificationOrigin) {\n      _writer.writeEnum(10, _instance.notificationOrigin);\n    }\n    if (_instance.originName) {\n      _writer.writeString(11, _instance.originName);\n    }\n    if (_instance.originLanguage) {\n      _writer.writeString(12, _instance.originLanguage);\n    }\n    if (_instance.notificationType) {\n      _writer.writeEnum(13, _instance.notificationType);\n    }\n    if (_instance.notificationVisibility) {\n      _writer.writeEnum(14, _instance.notificationVisibility);\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        15,\n        _instance.createdAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.modifiedAt) {\n      _writer.writeMessage(\n        16,\n        _instance.modifiedAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.createdBy) {\n      _writer.writeString(17, _instance.createdBy);\n    }\n    if (_instance.modifiedBy) {\n      _writer.writeString(18, _instance.modifiedBy);\n    }\n  }\n\n  private _name: string;\n  private _userName: string;\n  private _title: string;\n  private _descriptionShort: string;\n  private _descriptionLong: string;\n  private _notificationFlaggedStatus: NotificationFlaggedStatus;\n  private _notificationFlaggedTimestamp?: googleProtobuf001.Timestamp;\n  private _notificationReadStatus: NotificationReadStatus;\n  private _notificationReadTimestamp?: googleProtobuf001.Timestamp;\n  private _notificationOrigin: NotificationOrigin;\n  private _originName: string;\n  private _originLanguage: string;\n  private _notificationType: NotificationType;\n  private _notificationVisibility: NotificationVisibility;\n  private _createdAt?: googleProtobuf001.Timestamp;\n  private _modifiedAt?: googleProtobuf001.Timestamp;\n  private _createdBy: string;\n  private _modifiedBy: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of Notification to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Notification.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.userName = _value.userName;\n    this.title = _value.title;\n    this.descriptionShort = _value.descriptionShort;\n    this.descriptionLong = _value.descriptionLong;\n    this.notificationFlaggedStatus = _value.notificationFlaggedStatus;\n    this.notificationFlaggedTimestamp = _value.notificationFlaggedTimestamp\n      ? new googleProtobuf001.Timestamp(_value.notificationFlaggedTimestamp)\n      : undefined;\n    this.notificationReadStatus = _value.notificationReadStatus;\n    this.notificationReadTimestamp = _value.notificationReadTimestamp\n      ? new googleProtobuf001.Timestamp(_value.notificationReadTimestamp)\n      : undefined;\n    this.notificationOrigin = _value.notificationOrigin;\n    this.originName = _value.originName;\n    this.originLanguage = _value.originLanguage;\n    this.notificationType = _value.notificationType;\n    this.notificationVisibility = _value.notificationVisibility;\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf001.Timestamp(_value.createdAt)\n      : undefined;\n    this.modifiedAt = _value.modifiedAt\n      ? new googleProtobuf001.Timestamp(_value.modifiedAt)\n      : undefined;\n    this.createdBy = _value.createdBy;\n    this.modifiedBy = _value.modifiedBy;\n    Notification.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get userName(): string {\n    return this._userName;\n  }\n  set userName(value: string) {\n    this._userName = value;\n  }\n  get title(): string {\n    return this._title;\n  }\n  set title(value: string) {\n    this._title = value;\n  }\n  get descriptionShort(): string {\n    return this._descriptionShort;\n  }\n  set descriptionShort(value: string) {\n    this._descriptionShort = value;\n  }\n  get descriptionLong(): string {\n    return this._descriptionLong;\n  }\n  set descriptionLong(value: string) {\n    this._descriptionLong = value;\n  }\n  get notificationFlaggedStatus(): NotificationFlaggedStatus {\n    return this._notificationFlaggedStatus;\n  }\n  set notificationFlaggedStatus(value: NotificationFlaggedStatus) {\n    this._notificationFlaggedStatus = value;\n  }\n  get notificationFlaggedTimestamp(): googleProtobuf001.Timestamp | undefined {\n    return this._notificationFlaggedTimestamp;\n  }\n  set notificationFlaggedTimestamp(\n    value: googleProtobuf001.Timestamp | undefined\n  ) {\n    this._notificationFlaggedTimestamp = value;\n  }\n  get notificationReadStatus(): NotificationReadStatus {\n    return this._notificationReadStatus;\n  }\n  set notificationReadStatus(value: NotificationReadStatus) {\n    this._notificationReadStatus = value;\n  }\n  get notificationReadTimestamp(): googleProtobuf001.Timestamp | undefined {\n    return this._notificationReadTimestamp;\n  }\n  set notificationReadTimestamp(\n    value: googleProtobuf001.Timestamp | undefined\n  ) {\n    this._notificationReadTimestamp = value;\n  }\n  get notificationOrigin(): NotificationOrigin {\n    return this._notificationOrigin;\n  }\n  set notificationOrigin(value: NotificationOrigin) {\n    this._notificationOrigin = value;\n  }\n  get originName(): string {\n    return this._originName;\n  }\n  set originName(value: string) {\n    this._originName = value;\n  }\n  get originLanguage(): string {\n    return this._originLanguage;\n  }\n  set originLanguage(value: string) {\n    this._originLanguage = value;\n  }\n  get notificationType(): NotificationType {\n    return this._notificationType;\n  }\n  set notificationType(value: NotificationType) {\n    this._notificationType = value;\n  }\n  get notificationVisibility(): NotificationVisibility {\n    return this._notificationVisibility;\n  }\n  set notificationVisibility(value: NotificationVisibility) {\n    this._notificationVisibility = value;\n  }\n  get createdAt(): googleProtobuf001.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._createdAt = value;\n  }\n  get modifiedAt(): googleProtobuf001.Timestamp | undefined {\n    return this._modifiedAt;\n  }\n  set modifiedAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._modifiedAt = value;\n  }\n  get createdBy(): string {\n    return this._createdBy;\n  }\n  set createdBy(value: string) {\n    this._createdBy = value;\n  }\n  get modifiedBy(): string {\n    return this._modifiedBy;\n  }\n  set modifiedBy(value: string) {\n    this._modifiedBy = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Notification.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): Notification.AsObject {\n    return {\n      name: this.name,\n      userName: this.userName,\n      title: this.title,\n      descriptionShort: this.descriptionShort,\n      descriptionLong: this.descriptionLong,\n      notificationFlaggedStatus: this.notificationFlaggedStatus,\n      notificationFlaggedTimestamp: this.notificationFlaggedTimestamp\n        ? this.notificationFlaggedTimestamp.toObject()\n        : undefined,\n      notificationReadStatus: this.notificationReadStatus,\n      notificationReadTimestamp: this.notificationReadTimestamp\n        ? this.notificationReadTimestamp.toObject()\n        : undefined,\n      notificationOrigin: this.notificationOrigin,\n      originName: this.originName,\n      originLanguage: this.originLanguage,\n      notificationType: this.notificationType,\n      notificationVisibility: this.notificationVisibility,\n      createdAt: this.createdAt ? this.createdAt.toObject() : undefined,\n      modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): Notification.AsProtobufJSON {\n    return {\n      name: this.name,\n      userName: this.userName,\n      title: this.title,\n      descriptionShort: this.descriptionShort,\n      descriptionLong: this.descriptionLong,\n      notificationFlaggedStatus:\n        NotificationFlaggedStatus[\n          this.notificationFlaggedStatus === null ||\n          this.notificationFlaggedStatus === undefined\n            ? 0\n            : this.notificationFlaggedStatus\n        ],\n      notificationFlaggedTimestamp: this.notificationFlaggedTimestamp\n        ? this.notificationFlaggedTimestamp.toProtobufJSON(options)\n        : null,\n      notificationReadStatus:\n        NotificationReadStatus[\n          this.notificationReadStatus === null ||\n          this.notificationReadStatus === undefined\n            ? 0\n            : this.notificationReadStatus\n        ],\n      notificationReadTimestamp: this.notificationReadTimestamp\n        ? this.notificationReadTimestamp.toProtobufJSON(options)\n        : null,\n      notificationOrigin:\n        NotificationOrigin[\n          this.notificationOrigin === null ||\n          this.notificationOrigin === undefined\n            ? 0\n            : this.notificationOrigin\n        ],\n      originName: this.originName,\n      originLanguage: this.originLanguage,\n      notificationType:\n        NotificationType[\n          this.notificationType === null || this.notificationType === undefined\n            ? 0\n            : this.notificationType\n        ],\n      notificationVisibility:\n        NotificationVisibility[\n          this.notificationVisibility === null ||\n          this.notificationVisibility === undefined\n            ? 0\n            : this.notificationVisibility\n        ],\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,\n      modifiedAt: this.modifiedAt\n        ? this.modifiedAt.toProtobufJSON(options)\n        : null,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy\n    };\n  }\n}\nexport module Notification {\n  /**\n   * Standard JavaScript object representation for Notification\n   */\n  export interface AsObject {\n    name: string;\n    userName: string;\n    title: string;\n    descriptionShort: string;\n    descriptionLong: string;\n    notificationFlaggedStatus: NotificationFlaggedStatus;\n    notificationFlaggedTimestamp?: googleProtobuf001.Timestamp.AsObject;\n    notificationReadStatus: NotificationReadStatus;\n    notificationReadTimestamp?: googleProtobuf001.Timestamp.AsObject;\n    notificationOrigin: NotificationOrigin;\n    originName: string;\n    originLanguage: string;\n    notificationType: NotificationType;\n    notificationVisibility: NotificationVisibility;\n    createdAt?: googleProtobuf001.Timestamp.AsObject;\n    modifiedAt?: googleProtobuf001.Timestamp.AsObject;\n    createdBy: string;\n    modifiedBy: string;\n  }\n\n  /**\n   * Protobuf JSON representation for Notification\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    userName: string;\n    title: string;\n    descriptionShort: string;\n    descriptionLong: string;\n    notificationFlaggedStatus: string;\n    notificationFlaggedTimestamp: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    notificationReadStatus: string;\n    notificationReadTimestamp: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    notificationOrigin: string;\n    originName: string;\n    originLanguage: string;\n    notificationType: string;\n    notificationVisibility: string;\n    createdAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    modifiedAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    createdBy: string;\n    modifiedBy: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.AddNotificationsRequest\n */\nexport class AddNotificationsRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.AddNotificationsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new AddNotificationsRequest();\n    AddNotificationsRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: AddNotificationsRequest) {\n    _instance.notifications = _instance.notifications || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: AddNotificationsRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new Notification();\n          _reader.readMessage(\n            messageInitializer1,\n            Notification.deserializeBinaryFromReader\n          );\n          (_instance.notifications = _instance.notifications || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    AddNotificationsRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: AddNotificationsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.notifications && _instance.notifications.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.notifications as any,\n        Notification.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _notifications?: Notification[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of AddNotificationsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<AddNotificationsRequest.AsObject>) {\n    _value = _value || {};\n    this.notifications = (_value.notifications || []).map(\n      m => new Notification(m)\n    );\n    AddNotificationsRequest.refineValues(this);\n  }\n  get notifications(): Notification[] | undefined {\n    return this._notifications;\n  }\n  set notifications(value: Notification[] | undefined) {\n    this._notifications = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    AddNotificationsRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): AddNotificationsRequest.AsObject {\n    return {\n      notifications: (this.notifications || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): AddNotificationsRequest.AsProtobufJSON {\n    return {\n      notifications: (this.notifications || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module AddNotificationsRequest {\n  /**\n   * Standard JavaScript object representation for AddNotificationsRequest\n   */\n  export interface AsObject {\n    notifications?: Notification.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for AddNotificationsRequest\n   */\n  export interface AsProtobufJSON {\n    notifications: Notification.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.AddNotificationsResponse\n */\nexport class AddNotificationsResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.AddNotificationsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new AddNotificationsResponse();\n    AddNotificationsResponse.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: AddNotificationsResponse) {\n    _instance.notifications = _instance.notifications || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: AddNotificationsResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new Notification();\n          _reader.readMessage(\n            messageInitializer1,\n            Notification.deserializeBinaryFromReader\n          );\n          (_instance.notifications = _instance.notifications || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    AddNotificationsResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: AddNotificationsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.notifications && _instance.notifications.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.notifications as any,\n        Notification.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _notifications?: Notification[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of AddNotificationsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<AddNotificationsResponse.AsObject>) {\n    _value = _value || {};\n    this.notifications = (_value.notifications || []).map(\n      m => new Notification(m)\n    );\n    AddNotificationsResponse.refineValues(this);\n  }\n  get notifications(): Notification[] | undefined {\n    return this._notifications;\n  }\n  set notifications(value: Notification[] | undefined) {\n    this._notifications = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    AddNotificationsResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): AddNotificationsResponse.AsObject {\n    return {\n      notifications: (this.notifications || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): AddNotificationsResponse.AsProtobufJSON {\n    return {\n      notifications: (this.notifications || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module AddNotificationsResponse {\n  /**\n   * Standard JavaScript object representation for AddNotificationsResponse\n   */\n  export interface AsObject {\n    notifications?: Notification.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for AddNotificationsResponse\n   */\n  export interface AsProtobufJSON {\n    notifications: Notification.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.NotificationFilter\n */\nexport class NotificationFilter implements GrpcMessage {\n  static id = 'ondewo.nlu.NotificationFilter';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new NotificationFilter();\n    NotificationFilter.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: NotificationFilter) {\n    _instance.languageCodes = _instance.languageCodes || [];\n    _instance.notificationOrigins = _instance.notificationOrigins || [];\n    _instance.notificationVisibilities =\n      _instance.notificationVisibilities || [];\n    _instance.notificationFlaggedStatus =\n      _instance.notificationFlaggedStatus || [];\n    _instance.notificationReadStatus = _instance.notificationReadStatus || [];\n    _instance.earliest = _instance.earliest || undefined;\n    _instance.latest = _instance.latest || undefined;\n    _instance.userNames = _instance.userNames || [];\n    _instance.originNames = _instance.originNames || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: NotificationFilter,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.languageCodes = _instance.languageCodes || []).push(\n            _reader.readString()\n          );\n          break;\n        case 2:\n          (_instance.notificationOrigins =\n            _instance.notificationOrigins || []).push(\n            ...(_reader.readPackedEnum() || [])\n          );\n          break;\n        case 3:\n          (_instance.notificationVisibilities =\n            _instance.notificationVisibilities || []).push(\n            ...(_reader.readPackedEnum() || [])\n          );\n          break;\n        case 4:\n          (_instance.notificationFlaggedStatus =\n            _instance.notificationFlaggedStatus || []).push(\n            ...(_reader.readPackedEnum() || [])\n          );\n          break;\n        case 5:\n          (_instance.notificationReadStatus =\n            _instance.notificationReadStatus || []).push(\n            ...(_reader.readPackedEnum() || [])\n          );\n          break;\n        case 6:\n          _instance.earliest = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.earliest,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.latest = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.latest,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 8:\n          (_instance.userNames = _instance.userNames || []).push(\n            _reader.readString()\n          );\n          break;\n        case 9:\n          (_instance.originNames = _instance.originNames || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    NotificationFilter.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: NotificationFilter,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.languageCodes && _instance.languageCodes.length) {\n      _writer.writeRepeatedString(1, _instance.languageCodes);\n    }\n    if (_instance.notificationOrigins && _instance.notificationOrigins.length) {\n      _writer.writePackedEnum(2, _instance.notificationOrigins);\n    }\n    if (\n      _instance.notificationVisibilities &&\n      _instance.notificationVisibilities.length\n    ) {\n      _writer.writePackedEnum(3, _instance.notificationVisibilities);\n    }\n    if (\n      _instance.notificationFlaggedStatus &&\n      _instance.notificationFlaggedStatus.length\n    ) {\n      _writer.writePackedEnum(4, _instance.notificationFlaggedStatus);\n    }\n    if (\n      _instance.notificationReadStatus &&\n      _instance.notificationReadStatus.length\n    ) {\n      _writer.writePackedEnum(5, _instance.notificationReadStatus);\n    }\n    if (_instance.earliest) {\n      _writer.writeMessage(\n        6,\n        _instance.earliest as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.latest) {\n      _writer.writeMessage(\n        7,\n        _instance.latest as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.userNames && _instance.userNames.length) {\n      _writer.writeRepeatedString(8, _instance.userNames);\n    }\n    if (_instance.originNames && _instance.originNames.length) {\n      _writer.writeRepeatedString(9, _instance.originNames);\n    }\n  }\n\n  private _languageCodes: string[];\n  private _notificationOrigins: NotificationOrigin[];\n  private _notificationVisibilities: NotificationVisibility[];\n  private _notificationFlaggedStatus: NotificationFlaggedStatus[];\n  private _notificationReadStatus: NotificationReadStatus[];\n  private _earliest?: googleProtobuf001.Timestamp;\n  private _latest?: googleProtobuf001.Timestamp;\n  private _userNames: string[];\n  private _originNames: string[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of NotificationFilter to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<NotificationFilter.AsObject>) {\n    _value = _value || {};\n    this.languageCodes = (_value.languageCodes || []).slice();\n    this.notificationOrigins = (_value.notificationOrigins || []).slice();\n    this.notificationVisibilities = (\n      _value.notificationVisibilities || []\n    ).slice();\n    this.notificationFlaggedStatus = (\n      _value.notificationFlaggedStatus || []\n    ).slice();\n    this.notificationReadStatus = (_value.notificationReadStatus || []).slice();\n    this.earliest = _value.earliest\n      ? new googleProtobuf001.Timestamp(_value.earliest)\n      : undefined;\n    this.latest = _value.latest\n      ? new googleProtobuf001.Timestamp(_value.latest)\n      : undefined;\n    this.userNames = (_value.userNames || []).slice();\n    this.originNames = (_value.originNames || []).slice();\n    NotificationFilter.refineValues(this);\n  }\n  get languageCodes(): string[] {\n    return this._languageCodes;\n  }\n  set languageCodes(value: string[]) {\n    this._languageCodes = value;\n  }\n  get notificationOrigins(): NotificationOrigin[] {\n    return this._notificationOrigins;\n  }\n  set notificationOrigins(value: NotificationOrigin[]) {\n    this._notificationOrigins = value;\n  }\n  get notificationVisibilities(): NotificationVisibility[] {\n    return this._notificationVisibilities;\n  }\n  set notificationVisibilities(value: NotificationVisibility[]) {\n    this._notificationVisibilities = value;\n  }\n  get notificationFlaggedStatus(): NotificationFlaggedStatus[] {\n    return this._notificationFlaggedStatus;\n  }\n  set notificationFlaggedStatus(value: NotificationFlaggedStatus[]) {\n    this._notificationFlaggedStatus = value;\n  }\n  get notificationReadStatus(): NotificationReadStatus[] {\n    return this._notificationReadStatus;\n  }\n  set notificationReadStatus(value: NotificationReadStatus[]) {\n    this._notificationReadStatus = value;\n  }\n  get earliest(): googleProtobuf001.Timestamp | undefined {\n    return this._earliest;\n  }\n  set earliest(value: googleProtobuf001.Timestamp | undefined) {\n    this._earliest = value;\n  }\n  get latest(): googleProtobuf001.Timestamp | undefined {\n    return this._latest;\n  }\n  set latest(value: googleProtobuf001.Timestamp | undefined) {\n    this._latest = value;\n  }\n  get userNames(): string[] {\n    return this._userNames;\n  }\n  set userNames(value: string[]) {\n    this._userNames = value;\n  }\n  get originNames(): string[] {\n    return this._originNames;\n  }\n  set originNames(value: string[]) {\n    this._originNames = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    NotificationFilter.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): NotificationFilter.AsObject {\n    return {\n      languageCodes: (this.languageCodes || []).slice(),\n      notificationOrigins: (this.notificationOrigins || []).slice(),\n      notificationVisibilities: (this.notificationVisibilities || []).slice(),\n      notificationFlaggedStatus: (this.notificationFlaggedStatus || []).slice(),\n      notificationReadStatus: (this.notificationReadStatus || []).slice(),\n      earliest: this.earliest ? this.earliest.toObject() : undefined,\n      latest: this.latest ? this.latest.toObject() : undefined,\n      userNames: (this.userNames || []).slice(),\n      originNames: (this.originNames || []).slice()\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): NotificationFilter.AsProtobufJSON {\n    return {\n      languageCodes: (this.languageCodes || []).slice(),\n      notificationOrigins: (this.notificationOrigins || []).map(\n        v => NotificationOrigin[v]\n      ),\n      notificationVisibilities: (this.notificationVisibilities || []).map(\n        v => NotificationVisibility[v]\n      ),\n      notificationFlaggedStatus: (this.notificationFlaggedStatus || []).map(\n        v => NotificationFlaggedStatus[v]\n      ),\n      notificationReadStatus: (this.notificationReadStatus || []).map(\n        v => NotificationReadStatus[v]\n      ),\n      earliest: this.earliest ? this.earliest.toProtobufJSON(options) : null,\n      latest: this.latest ? this.latest.toProtobufJSON(options) : null,\n      userNames: (this.userNames || []).slice(),\n      originNames: (this.originNames || []).slice()\n    };\n  }\n}\nexport module NotificationFilter {\n  /**\n   * Standard JavaScript object representation for NotificationFilter\n   */\n  export interface AsObject {\n    languageCodes: string[];\n    notificationOrigins: NotificationOrigin[];\n    notificationVisibilities: NotificationVisibility[];\n    notificationFlaggedStatus: NotificationFlaggedStatus[];\n    notificationReadStatus: NotificationReadStatus[];\n    earliest?: googleProtobuf001.Timestamp.AsObject;\n    latest?: googleProtobuf001.Timestamp.AsObject;\n    userNames: string[];\n    originNames: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for NotificationFilter\n   */\n  export interface AsProtobufJSON {\n    languageCodes: string[];\n    notificationOrigins: string[];\n    notificationVisibilities: string[];\n    notificationFlaggedStatus: string[];\n    notificationReadStatus: string[];\n    earliest: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    latest: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    userNames: string[];\n    originNames: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListNotificationsRequest\n */\nexport class ListNotificationsRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListNotificationsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListNotificationsRequest();\n    ListNotificationsRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: ListNotificationsRequest) {\n    _instance.notificationFilter = _instance.notificationFilter || undefined;\n    _instance.pageToken = _instance.pageToken || '';\n    _instance.fieldMask = _instance.fieldMask || undefined;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: ListNotificationsRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.notificationFilter = new NotificationFilter();\n          _reader.readMessage(\n            _instance.notificationFilter,\n            NotificationFilter.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.pageToken = _reader.readString();\n          break;\n        case 3:\n          _instance.fieldMask = new googleProtobuf000.FieldMask();\n          _reader.readMessage(\n            _instance.fieldMask,\n            googleProtobuf000.FieldMask.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListNotificationsRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: ListNotificationsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.notificationFilter) {\n      _writer.writeMessage(\n        1,\n        _instance.notificationFilter as any,\n        NotificationFilter.serializeBinaryToWriter\n      );\n    }\n    if (_instance.pageToken) {\n      _writer.writeString(2, _instance.pageToken);\n    }\n    if (_instance.fieldMask) {\n      _writer.writeMessage(\n        3,\n        _instance.fieldMask as any,\n        googleProtobuf000.FieldMask.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _notificationFilter?: NotificationFilter;\n  private _pageToken: string;\n  private _fieldMask?: googleProtobuf000.FieldMask;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListNotificationsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListNotificationsRequest.AsObject>) {\n    _value = _value || {};\n    this.notificationFilter = _value.notificationFilter\n      ? new NotificationFilter(_value.notificationFilter)\n      : undefined;\n    this.pageToken = _value.pageToken;\n    this.fieldMask = _value.fieldMask\n      ? new googleProtobuf000.FieldMask(_value.fieldMask)\n      : undefined;\n    ListNotificationsRequest.refineValues(this);\n  }\n  get notificationFilter(): NotificationFilter | undefined {\n    return this._notificationFilter;\n  }\n  set notificationFilter(value: NotificationFilter | undefined) {\n    this._notificationFilter = value;\n  }\n  get pageToken(): string {\n    return this._pageToken;\n  }\n  set pageToken(value: string) {\n    this._pageToken = value;\n  }\n  get fieldMask(): googleProtobuf000.FieldMask | undefined {\n    return this._fieldMask;\n  }\n  set fieldMask(value: googleProtobuf000.FieldMask | undefined) {\n    this._fieldMask = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListNotificationsRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): ListNotificationsRequest.AsObject {\n    return {\n      notificationFilter: this.notificationFilter\n        ? this.notificationFilter.toObject()\n        : undefined,\n      pageToken: this.pageToken,\n      fieldMask: this.fieldMask ? this.fieldMask.toObject() : undefined\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): ListNotificationsRequest.AsProtobufJSON {\n    return {\n      notificationFilter: this.notificationFilter\n        ? this.notificationFilter.toProtobufJSON(options)\n        : null,\n      pageToken: this.pageToken,\n      fieldMask: this.fieldMask ? this.fieldMask.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module ListNotificationsRequest {\n  /**\n   * Standard JavaScript object representation for ListNotificationsRequest\n   */\n  export interface AsObject {\n    notificationFilter?: NotificationFilter.AsObject;\n    pageToken: string;\n    fieldMask?: googleProtobuf000.FieldMask.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ListNotificationsRequest\n   */\n  export interface AsProtobufJSON {\n    notificationFilter: NotificationFilter.AsProtobufJSON | null;\n    pageToken: string;\n    fieldMask: googleProtobuf000.FieldMask.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListNotificationsResponse\n */\nexport class ListNotificationsResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListNotificationsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListNotificationsResponse();\n    ListNotificationsResponse.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: ListNotificationsResponse) {\n    _instance.notifications = _instance.notifications || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: ListNotificationsResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new Notification();\n          _reader.readMessage(\n            messageInitializer1,\n            Notification.deserializeBinaryFromReader\n          );\n          (_instance.notifications = _instance.notifications || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListNotificationsResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: ListNotificationsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.notifications && _instance.notifications.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.notifications as any,\n        Notification.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _notifications?: Notification[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListNotificationsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListNotificationsResponse.AsObject>) {\n    _value = _value || {};\n    this.notifications = (_value.notifications || []).map(\n      m => new Notification(m)\n    );\n    ListNotificationsResponse.refineValues(this);\n  }\n  get notifications(): Notification[] | undefined {\n    return this._notifications;\n  }\n  set notifications(value: Notification[] | undefined) {\n    this._notifications = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListNotificationsResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): ListNotificationsResponse.AsObject {\n    return {\n      notifications: (this.notifications || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): ListNotificationsResponse.AsProtobufJSON {\n    return {\n      notifications: (this.notifications || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module ListNotificationsResponse {\n  /**\n   * Standard JavaScript object representation for ListNotificationsResponse\n   */\n  export interface AsObject {\n    notifications?: Notification.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for ListNotificationsResponse\n   */\n  export interface AsProtobufJSON {\n    notifications: Notification.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.SetNotificationsFlaggedStatusRequest\n */\nexport class SetNotificationsFlaggedStatusRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.SetNotificationsFlaggedStatusRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SetNotificationsFlaggedStatusRequest();\n    SetNotificationsFlaggedStatusRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: SetNotificationsFlaggedStatusRequest) {\n    _instance.notificationNames = _instance.notificationNames || [];\n    _instance.flagged = _instance.flagged || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: SetNotificationsFlaggedStatusRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.notificationNames =\n            _instance.notificationNames || []).push(_reader.readString());\n          break;\n        case 2:\n          (_instance.flagged = _instance.flagged || []).push(\n            ...(_reader.readPackedBool() || [])\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SetNotificationsFlaggedStatusRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: SetNotificationsFlaggedStatusRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.notificationNames && _instance.notificationNames.length) {\n      _writer.writeRepeatedString(1, _instance.notificationNames);\n    }\n    if (_instance.flagged && _instance.flagged.length) {\n      _writer.writePackedBool(2, _instance.flagged);\n    }\n  }\n\n  private _notificationNames: string[];\n  private _flagged: boolean[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SetNotificationsFlaggedStatusRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<SetNotificationsFlaggedStatusRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.notificationNames = (_value.notificationNames || []).slice();\n    this.flagged = (_value.flagged || []).slice();\n    SetNotificationsFlaggedStatusRequest.refineValues(this);\n  }\n  get notificationNames(): string[] {\n    return this._notificationNames;\n  }\n  set notificationNames(value: string[]) {\n    this._notificationNames = value;\n  }\n  get flagged(): boolean[] {\n    return this._flagged;\n  }\n  set flagged(value: boolean[]) {\n    this._flagged = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SetNotificationsFlaggedStatusRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): SetNotificationsFlaggedStatusRequest.AsObject {\n    return {\n      notificationNames: (this.notificationNames || []).slice(),\n      flagged: (this.flagged || []).slice()\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): SetNotificationsFlaggedStatusRequest.AsProtobufJSON {\n    return {\n      notificationNames: (this.notificationNames || []).slice(),\n      flagged: (this.flagged || []).slice()\n    };\n  }\n}\nexport module SetNotificationsFlaggedStatusRequest {\n  /**\n   * Standard JavaScript object representation for SetNotificationsFlaggedStatusRequest\n   */\n  export interface AsObject {\n    notificationNames: string[];\n    flagged: boolean[];\n  }\n\n  /**\n   * Protobuf JSON representation for SetNotificationsFlaggedStatusRequest\n   */\n  export interface AsProtobufJSON {\n    notificationNames: string[];\n    flagged: boolean[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.SetNotificationsReadStatusRequest\n */\nexport class SetNotificationsReadStatusRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.SetNotificationsReadStatusRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SetNotificationsReadStatusRequest();\n    SetNotificationsReadStatusRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: SetNotificationsReadStatusRequest) {\n    _instance.notificationNames = _instance.notificationNames || [];\n    _instance.flagged = _instance.flagged || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: SetNotificationsReadStatusRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.notificationNames =\n            _instance.notificationNames || []).push(_reader.readString());\n          break;\n        case 2:\n          (_instance.flagged = _instance.flagged || []).push(\n            ...(_reader.readPackedBool() || [])\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SetNotificationsReadStatusRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: SetNotificationsReadStatusRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.notificationNames && _instance.notificationNames.length) {\n      _writer.writeRepeatedString(1, _instance.notificationNames);\n    }\n    if (_instance.flagged && _instance.flagged.length) {\n      _writer.writePackedBool(2, _instance.flagged);\n    }\n  }\n\n  private _notificationNames: string[];\n  private _flagged: boolean[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SetNotificationsReadStatusRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<SetNotificationsReadStatusRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.notificationNames = (_value.notificationNames || []).slice();\n    this.flagged = (_value.flagged || []).slice();\n    SetNotificationsReadStatusRequest.refineValues(this);\n  }\n  get notificationNames(): string[] {\n    return this._notificationNames;\n  }\n  set notificationNames(value: string[]) {\n    this._notificationNames = value;\n  }\n  get flagged(): boolean[] {\n    return this._flagged;\n  }\n  set flagged(value: boolean[]) {\n    this._flagged = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SetNotificationsReadStatusRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): SetNotificationsReadStatusRequest.AsObject {\n    return {\n      notificationNames: (this.notificationNames || []).slice(),\n      flagged: (this.flagged || []).slice()\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): SetNotificationsReadStatusRequest.AsProtobufJSON {\n    return {\n      notificationNames: (this.notificationNames || []).slice(),\n      flagged: (this.flagged || []).slice()\n    };\n  }\n}\nexport module SetNotificationsReadStatusRequest {\n  /**\n   * Standard JavaScript object representation for SetNotificationsReadStatusRequest\n   */\n  export interface AsObject {\n    notificationNames: string[];\n    flagged: boolean[];\n  }\n\n  /**\n   * Protobuf JSON representation for SetNotificationsReadStatusRequest\n   */\n  export interface AsProtobufJSON {\n    notificationNames: string[];\n    flagged: boolean[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.KeyValuePair\n */\nexport class KeyValuePair implements GrpcMessage {\n  static id = 'ondewo.nlu.KeyValuePair';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new KeyValuePair();\n    KeyValuePair.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: KeyValuePair) {\n    _instance.key = _instance.key || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: KeyValuePair,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.key = _reader.readString();\n          break;\n        case 2:\n          _instance.intValue = _reader.readInt32();\n          break;\n        case 3:\n          _instance.floatValue = _reader.readFloat();\n          break;\n        case 4:\n          _instance.doubleValue = _reader.readDouble();\n          break;\n        case 5:\n          _instance.stringValue = _reader.readString();\n          break;\n        case 6:\n          _instance.createdAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    KeyValuePair.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: KeyValuePair,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.key) {\n      _writer.writeString(1, _instance.key);\n    }\n    if (_instance.intValue || _instance.intValue === 0) {\n      _writer.writeInt32(2, _instance.intValue);\n    }\n    if (_instance.floatValue || _instance.floatValue === 0) {\n      _writer.writeFloat(3, _instance.floatValue);\n    }\n    if (_instance.doubleValue || _instance.doubleValue === 0) {\n      _writer.writeDouble(4, _instance.doubleValue);\n    }\n    if (_instance.stringValue || _instance.stringValue === '') {\n      _writer.writeString(5, _instance.stringValue);\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        6,\n        _instance.createdAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _key: string;\n  private _intValue: number;\n  private _floatValue: number;\n  private _doubleValue: number;\n  private _stringValue: string;\n  private _createdAt?: googleProtobuf001.Timestamp;\n\n  private _value: KeyValuePair.ValueCase = KeyValuePair.ValueCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of KeyValuePair to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<KeyValuePair.AsObject>) {\n    _value = _value || {};\n    this.key = _value.key;\n    this.intValue = _value.intValue;\n    this.floatValue = _value.floatValue;\n    this.doubleValue = _value.doubleValue;\n    this.stringValue = _value.stringValue;\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf001.Timestamp(_value.createdAt)\n      : undefined;\n    KeyValuePair.refineValues(this);\n  }\n  get key(): string {\n    return this._key;\n  }\n  set key(value: string) {\n    this._key = value;\n  }\n  get intValue(): number {\n    return this._intValue;\n  }\n  set intValue(value: number) {\n    if (value !== undefined && value !== null) {\n      this._floatValue = this._doubleValue = this._stringValue = this._createdAt = undefined;\n      this._value = KeyValuePair.ValueCase.intValue;\n    }\n    this._intValue = value;\n  }\n  get floatValue(): number {\n    return this._floatValue;\n  }\n  set floatValue(value: number) {\n    if (value !== undefined && value !== null) {\n      this._intValue = this._doubleValue = this._stringValue = this._createdAt = undefined;\n      this._value = KeyValuePair.ValueCase.floatValue;\n    }\n    this._floatValue = value;\n  }\n  get doubleValue(): number {\n    return this._doubleValue;\n  }\n  set doubleValue(value: number) {\n    if (value !== undefined && value !== null) {\n      this._intValue = this._floatValue = this._stringValue = this._createdAt = undefined;\n      this._value = KeyValuePair.ValueCase.doubleValue;\n    }\n    this._doubleValue = value;\n  }\n  get stringValue(): string {\n    return this._stringValue;\n  }\n  set stringValue(value: string) {\n    if (value !== undefined && value !== null) {\n      this._intValue = this._floatValue = this._doubleValue = this._createdAt = undefined;\n      this._value = KeyValuePair.ValueCase.stringValue;\n    }\n    this._stringValue = value;\n  }\n  get createdAt(): googleProtobuf001.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf001.Timestamp | undefined) {\n    if (value !== undefined && value !== null) {\n      this._intValue = this._floatValue = this._doubleValue = this._stringValue = undefined;\n      this._value = KeyValuePair.ValueCase.createdAt;\n    }\n    this._createdAt = value;\n  }\n  get value() {\n    return this._value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    KeyValuePair.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): KeyValuePair.AsObject {\n    return {\n      key: this.key,\n      intValue: this.intValue,\n      floatValue: this.floatValue,\n      doubleValue: this.doubleValue,\n      stringValue: this.stringValue,\n      createdAt: this.createdAt ? this.createdAt.toObject() : undefined\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): KeyValuePair.AsProtobufJSON {\n    return {\n      key: this.key,\n      intValue:\n        this.intValue === null || this.intValue === undefined\n          ? null\n          : this.intValue,\n      floatValue:\n        this.floatValue === null || this.floatValue === undefined\n          ? null\n          : this.floatValue,\n      doubleValue:\n        this.doubleValue === null || this.doubleValue === undefined\n          ? null\n          : this.doubleValue,\n      stringValue:\n        this.stringValue === null || this.stringValue === undefined\n          ? null\n          : this.stringValue,\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module KeyValuePair {\n  /**\n   * Standard JavaScript object representation for KeyValuePair\n   */\n  export interface AsObject {\n    key: string;\n    intValue: number;\n    floatValue: number;\n    doubleValue: number;\n    stringValue: string;\n    createdAt?: googleProtobuf001.Timestamp.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for KeyValuePair\n   */\n  export interface AsProtobufJSON {\n    key: string;\n    intValue: number | null;\n    floatValue: number | null;\n    doubleValue: number | null;\n    stringValue: string | null;\n    createdAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n  }\n  export enum ValueCase {\n    none = 0,\n    intValue = 1,\n    floatValue = 2,\n    doubleValue = 3,\n    stringValue = 4,\n    createdAt = 5\n  }\n}\n"]}