@ondewo/csi-client-angular 2.3.1

package/esm2020/api/ondewo/nlu/user.pb.mjs

@@ -0,0 +1,2536 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf003 from '@ngx-grpc/well-known-types';
+import * as ondewoNlu005 from '../../ondewo/nlu/project-role.pb';
+export var DefaultServerRole;
+(function (DefaultServerRole) {
+    DefaultServerRole[DefaultServerRole["SERVER_UNSPECIFIED"] = 0] = "SERVER_UNSPECIFIED";
+    DefaultServerRole[DefaultServerRole["SERVER_USER"] = 1] = "SERVER_USER";
+    DefaultServerRole[DefaultServerRole["SERVER_MANAGER"] = 2] = "SERVER_MANAGER";
+    DefaultServerRole[DefaultServerRole["SERVER_ADMIN"] = 3] = "SERVER_ADMIN";
+    DefaultServerRole[DefaultServerRole["SERVER_INACTIVE"] = 4] = "SERVER_INACTIVE";
+})(DefaultServerRole || (DefaultServerRole = {}));
+/**
+ * Message implementation for ondewo.nlu.User
+ */
+export class User {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of User to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.userId = _value.userId;
+        this.displayName = _value.displayName;
+        this.serverRoleId = _value.serverRoleId;
+        this.userEmail = _value.userEmail;
+        User.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new User();
+        User.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.userId = _instance.userId || '';
+        _instance.displayName = _instance.displayName || '';
+        _instance.serverRoleId = _instance.serverRoleId || 0;
+        _instance.userEmail = _instance.userEmail || '';
+    }
+    /**
+     * 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 2:
+                    _instance.userId = _reader.readString();
+                    break;
+                case 3:
+                    _instance.displayName = _reader.readString();
+                    break;
+                case 6:
+                    _instance.serverRoleId = _reader.readUint32();
+                    break;
+                case 7:
+                    _instance.userEmail = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        User.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.userId) {
+            _writer.writeString(2, _instance.userId);
+        }
+        if (_instance.displayName) {
+            _writer.writeString(3, _instance.displayName);
+        }
+        if (_instance.serverRoleId) {
+            _writer.writeUint32(6, _instance.serverRoleId);
+        }
+        if (_instance.userEmail) {
+            _writer.writeString(7, _instance.userEmail);
+        }
+    }
+    get userId() {
+        return this._userId;
+    }
+    set userId(value) {
+        this._userId = value;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    set displayName(value) {
+        this._displayName = value;
+    }
+    get serverRoleId() {
+        return this._serverRoleId;
+    }
+    set serverRoleId(value) {
+        this._serverRoleId = value;
+    }
+    get userEmail() {
+        return this._userEmail;
+    }
+    set userEmail(value) {
+        this._userEmail = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        User.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            userId: this.userId,
+            displayName: this.displayName,
+            serverRoleId: this.serverRoleId,
+            userEmail: this.userEmail
+        };
+    }
+    /**
+     * 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 {
+            userId: this.userId,
+            displayName: this.displayName,
+            serverRoleId: this.serverRoleId,
+            userEmail: this.userEmail
+        };
+    }
+}
+User.id = 'ondewo.nlu.User';
+/**
+ * Message implementation for ondewo.nlu.UserInfo
+ */
+export class UserInfo {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of UserInfo to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.user = _value.user ? new User(_value.user) : undefined;
+        (this.projectRoles = _value.projectRoles
+            ? Object.keys(_value.projectRoles).reduce((r, k) => ({
+                ...r,
+                [k]: _value.projectRoles[k]
+                    ? new ondewoNlu005.ProjectRole(_value.projectRoles[k])
+                    : undefined
+            }), {})
+            : {}),
+            UserInfo.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new UserInfo();
+        UserInfo.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.user = _instance.user || undefined;
+        _instance.projectRoles = _instance.projectRoles || {};
+    }
+    /**
+     * 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.user = new User();
+                    _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    const msg_2 = {};
+                    _reader.readMessage(msg_2, UserInfo.ProjectRolesEntry.deserializeBinaryFromReader);
+                    _instance.projectRoles = _instance.projectRoles || {};
+                    _instance.projectRoles[msg_2.key] = msg_2.value;
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        UserInfo.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.user) {
+            _writer.writeMessage(1, _instance.user, User.serializeBinaryToWriter);
+        }
+        if (!!_instance.projectRoles) {
+            const keys_2 = Object.keys(_instance.projectRoles);
+            if (keys_2.length) {
+                const repeated_2 = keys_2
+                    .map(key => ({
+                    key: key,
+                    value: _instance.projectRoles[key]
+                }))
+                    .reduce((r, v) => [...r, v], []);
+                _writer.writeRepeatedMessage(2, repeated_2, UserInfo.ProjectRolesEntry.serializeBinaryToWriter);
+            }
+        }
+    }
+    get user() {
+        return this._user;
+    }
+    set user(value) {
+        this._user = value;
+    }
+    get projectRoles() {
+        return this._projectRoles;
+    }
+    set projectRoles(value) {
+        this._projectRoles = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        UserInfo.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            user: this.user ? this.user.toObject() : undefined,
+            projectRoles: this.projectRoles
+                ? Object.keys(this.projectRoles).reduce((r, k) => ({
+                    ...r,
+                    [k]: this.projectRoles[k]
+                        ? this.projectRoles[k].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 {
+            user: this.user ? this.user.toProtobufJSON(options) : null,
+            projectRoles: this.projectRoles
+                ? Object.keys(this.projectRoles).reduce((r, k) => ({
+                    ...r,
+                    [k]: this.projectRoles[k] ? this.projectRoles[k].toJSON() : null
+                }), {})
+                : {}
+        };
+    }
+}
+UserInfo.id = 'ondewo.nlu.UserInfo';
+(function (UserInfo) {
+    /**
+     * Message implementation for ondewo.nlu.ProjectRolesEntry
+     */
+    class ProjectRolesEntry {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of ProjectRolesEntry to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.key = _value.key;
+            this.value = _value.value
+                ? new ondewoNlu005.ProjectRole(_value.value)
+                : undefined;
+            ProjectRolesEntry.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new ProjectRolesEntry();
+            ProjectRolesEntry.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 || '';
+            _instance.value = _instance.value || 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.key = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.value = new ondewoNlu005.ProjectRole();
+                        _reader.readMessage(_instance.value, ondewoNlu005.ProjectRole.deserializeBinaryFromReader);
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            ProjectRolesEntry.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.value) {
+                _writer.writeMessage(2, _instance.value, ondewoNlu005.ProjectRole.serializeBinaryToWriter);
+            }
+        }
+        get key() {
+            return this._key;
+        }
+        set key(value) {
+            this._key = value;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            ProjectRolesEntry.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                key: this.key,
+                value: this.value ? this.value.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,
+                value: this.value ? this.value.toProtobufJSON(options) : null
+            };
+        }
+    }
+    ProjectRolesEntry.id = 'ondewo.nlu.ProjectRolesEntry';
+    UserInfo.ProjectRolesEntry = ProjectRolesEntry;
+})(UserInfo || (UserInfo = {}));
+/**
+ * Message implementation for ondewo.nlu.CreateUserRequest
+ */
+export class CreateUserRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CreateUserRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.user = _value.user ? new User(_value.user) : undefined;
+        this.password = _value.password;
+        CreateUserRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CreateUserRequest();
+        CreateUserRequest.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.user = _instance.user || undefined;
+        _instance.password = _instance.password || '';
+    }
+    /**
+     * 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.user = new User();
+                    _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.password = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CreateUserRequest.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.user) {
+            _writer.writeMessage(1, _instance.user, User.serializeBinaryToWriter);
+        }
+        if (_instance.password) {
+            _writer.writeString(3, _instance.password);
+        }
+    }
+    get user() {
+        return this._user;
+    }
+    set user(value) {
+        this._user = value;
+    }
+    get password() {
+        return this._password;
+    }
+    set password(value) {
+        this._password = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CreateUserRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            user: this.user ? this.user.toObject() : undefined,
+            password: this.password
+        };
+    }
+    /**
+     * 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 {
+            user: this.user ? this.user.toProtobufJSON(options) : null,
+            password: this.password
+        };
+    }
+}
+CreateUserRequest.id = 'ondewo.nlu.CreateUserRequest';
+/**
+ * Message implementation for ondewo.nlu.UpdateUserRequest
+ */
+export class UpdateUserRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of UpdateUserRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.user = _value.user ? new User(_value.user) : undefined;
+        this.password = _value.password;
+        this.updateMask = _value.updateMask
+            ? new googleProtobuf003.FieldMask(_value.updateMask)
+            : undefined;
+        UpdateUserRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new UpdateUserRequest();
+        UpdateUserRequest.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.user = _instance.user || undefined;
+        _instance.password = _instance.password || '';
+        _instance.updateMask = _instance.updateMask || 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.user = new User();
+                    _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.password = _reader.readString();
+                    break;
+                case 5:
+                    _instance.updateMask = new googleProtobuf003.FieldMask();
+                    _reader.readMessage(_instance.updateMask, googleProtobuf003.FieldMask.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        UpdateUserRequest.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.user) {
+            _writer.writeMessage(1, _instance.user, User.serializeBinaryToWriter);
+        }
+        if (_instance.password) {
+            _writer.writeString(4, _instance.password);
+        }
+        if (_instance.updateMask) {
+            _writer.writeMessage(5, _instance.updateMask, googleProtobuf003.FieldMask.serializeBinaryToWriter);
+        }
+    }
+    get user() {
+        return this._user;
+    }
+    set user(value) {
+        this._user = value;
+    }
+    get password() {
+        return this._password;
+    }
+    set password(value) {
+        this._password = value;
+    }
+    get updateMask() {
+        return this._updateMask;
+    }
+    set updateMask(value) {
+        this._updateMask = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        UpdateUserRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            user: this.user ? this.user.toObject() : undefined,
+            password: this.password,
+            updateMask: this.updateMask ? this.updateMask.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 {
+            user: this.user ? this.user.toProtobufJSON(options) : null,
+            password: this.password,
+            updateMask: this.updateMask
+                ? this.updateMask.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+UpdateUserRequest.id = 'ondewo.nlu.UpdateUserRequest';
+/**
+ * Message implementation for ondewo.nlu.GetUserRequest
+ */
+export class GetUserRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetUserRequest to deeply clone from
+     */
+    constructor(_value) {
+        this._userIdentifier = GetUserRequest.UserIdentifierCase.none;
+        _value = _value || {};
+        this.userId = _value.userId;
+        this.userEmail = _value.userEmail;
+        GetUserRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetUserRequest();
+        GetUserRequest.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) { }
+    /**
+     * 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.userId = _reader.readString();
+                    break;
+                case 3:
+                    _instance.userEmail = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetUserRequest.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.userId || _instance.userId === '') {
+            _writer.writeString(1, _instance.userId);
+        }
+        if (_instance.userEmail || _instance.userEmail === '') {
+            _writer.writeString(3, _instance.userEmail);
+        }
+    }
+    get userId() {
+        return this._userId;
+    }
+    set userId(value) {
+        if (value !== undefined && value !== null) {
+            this._userEmail = undefined;
+            this._userIdentifier = GetUserRequest.UserIdentifierCase.userId;
+        }
+        this._userId = value;
+    }
+    get userEmail() {
+        return this._userEmail;
+    }
+    set userEmail(value) {
+        if (value !== undefined && value !== null) {
+            this._userId = undefined;
+            this._userIdentifier = GetUserRequest.UserIdentifierCase.userEmail;
+        }
+        this._userEmail = value;
+    }
+    get userIdentifier() {
+        return this._userIdentifier;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetUserRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            userId: this.userId,
+            userEmail: this.userEmail
+        };
+    }
+    /**
+     * 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 {
+            userId: this.userId === null || this.userId === undefined ? null : this.userId,
+            userEmail: this.userEmail === null || this.userEmail === undefined
+                ? null
+                : this.userEmail
+        };
+    }
+}
+GetUserRequest.id = 'ondewo.nlu.GetUserRequest';
+(function (GetUserRequest) {
+    let UserIdentifierCase;
+    (function (UserIdentifierCase) {
+        UserIdentifierCase[UserIdentifierCase["none"] = 0] = "none";
+        UserIdentifierCase[UserIdentifierCase["userId"] = 1] = "userId";
+        UserIdentifierCase[UserIdentifierCase["userEmail"] = 2] = "userEmail";
+    })(UserIdentifierCase = GetUserRequest.UserIdentifierCase || (GetUserRequest.UserIdentifierCase = {}));
+})(GetUserRequest || (GetUserRequest = {}));
+/**
+ * Message implementation for ondewo.nlu.DeleteUserRequest
+ */
+export class DeleteUserRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DeleteUserRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.userId = _value.userId;
+        DeleteUserRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new DeleteUserRequest();
+        DeleteUserRequest.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.userId = _instance.userId || '';
+    }
+    /**
+     * 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.userId = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        DeleteUserRequest.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.userId) {
+            _writer.writeString(1, _instance.userId);
+        }
+    }
+    get userId() {
+        return this._userId;
+    }
+    set userId(value) {
+        this._userId = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        DeleteUserRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            userId: this.userId
+        };
+    }
+    /**
+     * 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 {
+            userId: this.userId
+        };
+    }
+}
+DeleteUserRequest.id = 'ondewo.nlu.DeleteUserRequest';
+/**
+ * Message implementation for ondewo.nlu.ListUsersRequest
+ */
+export class ListUsersRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListUsersRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.pageToken = _value.pageToken;
+        ListUsersRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListUsersRequest();
+        ListUsersRequest.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.pageToken = _instance.pageToken || '';
+    }
+    /**
+     * 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.pageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListUsersRequest.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.pageToken) {
+            _writer.writeString(1, _instance.pageToken);
+        }
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListUsersRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            pageToken: this.pageToken
+        };
+    }
+    /**
+     * 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 {
+            pageToken: this.pageToken
+        };
+    }
+}
+ListUsersRequest.id = 'ondewo.nlu.ListUsersRequest';
+/**
+ * Message implementation for ondewo.nlu.ListUsersResponse
+ */
+export class ListUsersResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListUsersResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.users = (_value.users || []).map(m => new User(m));
+        this.nextPageToken = _value.nextPageToken;
+        ListUsersResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListUsersResponse();
+        ListUsersResponse.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.users = _instance.users || [];
+        _instance.nextPageToken = _instance.nextPageToken || '';
+    }
+    /**
+     * 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 User();
+                    _reader.readMessage(messageInitializer1, User.deserializeBinaryFromReader);
+                    (_instance.users = _instance.users || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListUsersResponse.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.users && _instance.users.length) {
+            _writer.writeRepeatedMessage(1, _instance.users, User.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    get users() {
+        return this._users;
+    }
+    set users(value) {
+        this._users = value;
+    }
+    get nextPageToken() {
+        return this._nextPageToken;
+    }
+    set nextPageToken(value) {
+        this._nextPageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListUsersResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            users: (this.users || []).map(m => m.toObject()),
+            nextPageToken: this.nextPageToken
+        };
+    }
+    /**
+     * 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 {
+            users: (this.users || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+ListUsersResponse.id = 'ondewo.nlu.ListUsersResponse';
+/**
+ * Message implementation for ondewo.nlu.ListUserInfosResponse
+ */
+export class ListUserInfosResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListUserInfosResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.users = (_value.users || []).map(m => new UserInfo(m));
+        this.nextPageToken = _value.nextPageToken;
+        ListUserInfosResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListUserInfosResponse();
+        ListUserInfosResponse.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.users = _instance.users || [];
+        _instance.nextPageToken = _instance.nextPageToken || '';
+    }
+    /**
+     * 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 UserInfo();
+                    _reader.readMessage(messageInitializer1, UserInfo.deserializeBinaryFromReader);
+                    (_instance.users = _instance.users || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListUserInfosResponse.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.users && _instance.users.length) {
+            _writer.writeRepeatedMessage(1, _instance.users, UserInfo.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    get users() {
+        return this._users;
+    }
+    set users(value) {
+        this._users = value;
+    }
+    get nextPageToken() {
+        return this._nextPageToken;
+    }
+    set nextPageToken(value) {
+        this._nextPageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListUserInfosResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            users: (this.users || []).map(m => m.toObject()),
+            nextPageToken: this.nextPageToken
+        };
+    }
+    /**
+     * 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 {
+            users: (this.users || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+ListUserInfosResponse.id = 'ondewo.nlu.ListUserInfosResponse';
+/**
+ * Message implementation for ondewo.nlu.ServerRole
+ */
+export class ServerRole {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ServerRole to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.roleId = _value.roleId;
+        this.name = _value.name;
+        this.permissions = (_value.permissions || []).slice();
+        ServerRole.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ServerRole();
+        ServerRole.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.roleId = _instance.roleId || 0;
+        _instance.name = _instance.name || '';
+        _instance.permissions = _instance.permissions || [];
+    }
+    /**
+     * 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.roleId = _reader.readUint32();
+                    break;
+                case 2:
+                    _instance.name = _reader.readString();
+                    break;
+                case 3:
+                    (_instance.permissions = _instance.permissions || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ServerRole.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.roleId) {
+            _writer.writeUint32(1, _instance.roleId);
+        }
+        if (_instance.name) {
+            _writer.writeString(2, _instance.name);
+        }
+        if (_instance.permissions && _instance.permissions.length) {
+            _writer.writeRepeatedString(3, _instance.permissions);
+        }
+    }
+    get roleId() {
+        return this._roleId;
+    }
+    set roleId(value) {
+        this._roleId = value;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get permissions() {
+        return this._permissions;
+    }
+    set permissions(value) {
+        this._permissions = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ServerRole.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            roleId: this.roleId,
+            name: this.name,
+            permissions: (this.permissions || []).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 {
+            roleId: this.roleId,
+            name: this.name,
+            permissions: (this.permissions || []).slice()
+        };
+    }
+}
+ServerRole.id = 'ondewo.nlu.ServerRole';
+/**
+ * Message implementation for ondewo.nlu.CreateServerRoleRequest
+ */
+export class CreateServerRoleRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CreateServerRoleRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.role = _value.role ? new ServerRole(_value.role) : undefined;
+        CreateServerRoleRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CreateServerRoleRequest();
+        CreateServerRoleRequest.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.role = _instance.role || 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.role = new ServerRole();
+                    _reader.readMessage(_instance.role, ServerRole.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CreateServerRoleRequest.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.role) {
+            _writer.writeMessage(1, _instance.role, ServerRole.serializeBinaryToWriter);
+        }
+    }
+    get role() {
+        return this._role;
+    }
+    set role(value) {
+        this._role = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CreateServerRoleRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            role: this.role ? this.role.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 {
+            role: this.role ? this.role.toProtobufJSON(options) : null
+        };
+    }
+}
+CreateServerRoleRequest.id = 'ondewo.nlu.CreateServerRoleRequest';
+/**
+ * Message implementation for ondewo.nlu.UpdateServerRoleRequest
+ */
+export class UpdateServerRoleRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of UpdateServerRoleRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.role = _value.role ? new ServerRole(_value.role) : undefined;
+        this.updateMask = _value.updateMask
+            ? new googleProtobuf003.FieldMask(_value.updateMask)
+            : undefined;
+        UpdateServerRoleRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new UpdateServerRoleRequest();
+        UpdateServerRoleRequest.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.role = _instance.role || undefined;
+        _instance.updateMask = _instance.updateMask || 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.role = new ServerRole();
+                    _reader.readMessage(_instance.role, ServerRole.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.updateMask = new googleProtobuf003.FieldMask();
+                    _reader.readMessage(_instance.updateMask, googleProtobuf003.FieldMask.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        UpdateServerRoleRequest.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.role) {
+            _writer.writeMessage(1, _instance.role, ServerRole.serializeBinaryToWriter);
+        }
+        if (_instance.updateMask) {
+            _writer.writeMessage(2, _instance.updateMask, googleProtobuf003.FieldMask.serializeBinaryToWriter);
+        }
+    }
+    get role() {
+        return this._role;
+    }
+    set role(value) {
+        this._role = value;
+    }
+    get updateMask() {
+        return this._updateMask;
+    }
+    set updateMask(value) {
+        this._updateMask = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        UpdateServerRoleRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            role: this.role ? this.role.toObject() : undefined,
+            updateMask: this.updateMask ? this.updateMask.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 {
+            role: this.role ? this.role.toProtobufJSON(options) : null,
+            updateMask: this.updateMask
+                ? this.updateMask.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+UpdateServerRoleRequest.id = 'ondewo.nlu.UpdateServerRoleRequest';
+/**
+ * Message implementation for ondewo.nlu.DeleteServerRoleRequest
+ */
+export class DeleteServerRoleRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DeleteServerRoleRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.roleId = _value.roleId;
+        DeleteServerRoleRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new DeleteServerRoleRequest();
+        DeleteServerRoleRequest.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.roleId = _instance.roleId || 0;
+    }
+    /**
+     * 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.roleId = _reader.readUint32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        DeleteServerRoleRequest.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.roleId) {
+            _writer.writeUint32(1, _instance.roleId);
+        }
+    }
+    get roleId() {
+        return this._roleId;
+    }
+    set roleId(value) {
+        this._roleId = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        DeleteServerRoleRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            roleId: this.roleId
+        };
+    }
+    /**
+     * 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 {
+            roleId: this.roleId
+        };
+    }
+}
+DeleteServerRoleRequest.id = 'ondewo.nlu.DeleteServerRoleRequest';
+/**
+ * Message implementation for ondewo.nlu.GetServerRoleRequest
+ */
+export class GetServerRoleRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetServerRoleRequest to deeply clone from
+     */
+    constructor(_value) {
+        this._serverRoleIdentifier = GetServerRoleRequest.ServerRoleIdentifierCase.none;
+        _value = _value || {};
+        this.roleId = _value.roleId;
+        this.roleName = _value.roleName;
+        GetServerRoleRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetServerRoleRequest();
+        GetServerRoleRequest.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) { }
+    /**
+     * 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.roleId = _reader.readUint32();
+                    break;
+                case 2:
+                    _instance.roleName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetServerRoleRequest.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.roleId || _instance.roleId === 0) {
+            _writer.writeUint32(1, _instance.roleId);
+        }
+        if (_instance.roleName || _instance.roleName === '') {
+            _writer.writeString(2, _instance.roleName);
+        }
+    }
+    get roleId() {
+        return this._roleId;
+    }
+    set roleId(value) {
+        if (value !== undefined && value !== null) {
+            this._roleName = undefined;
+            this._serverRoleIdentifier =
+                GetServerRoleRequest.ServerRoleIdentifierCase.roleId;
+        }
+        this._roleId = value;
+    }
+    get roleName() {
+        return this._roleName;
+    }
+    set roleName(value) {
+        if (value !== undefined && value !== null) {
+            this._roleId = undefined;
+            this._serverRoleIdentifier =
+                GetServerRoleRequest.ServerRoleIdentifierCase.roleName;
+        }
+        this._roleName = value;
+    }
+    get serverRoleIdentifier() {
+        return this._serverRoleIdentifier;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetServerRoleRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            roleId: this.roleId,
+            roleName: this.roleName
+        };
+    }
+    /**
+     * 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 {
+            roleId: this.roleId === null || this.roleId === undefined ? null : this.roleId,
+            roleName: this.roleName === null || this.roleName === undefined
+                ? null
+                : this.roleName
+        };
+    }
+}
+GetServerRoleRequest.id = 'ondewo.nlu.GetServerRoleRequest';
+(function (GetServerRoleRequest) {
+    let ServerRoleIdentifierCase;
+    (function (ServerRoleIdentifierCase) {
+        ServerRoleIdentifierCase[ServerRoleIdentifierCase["none"] = 0] = "none";
+        ServerRoleIdentifierCase[ServerRoleIdentifierCase["roleId"] = 1] = "roleId";
+        ServerRoleIdentifierCase[ServerRoleIdentifierCase["roleName"] = 2] = "roleName";
+    })(ServerRoleIdentifierCase = GetServerRoleRequest.ServerRoleIdentifierCase || (GetServerRoleRequest.ServerRoleIdentifierCase = {}));
+})(GetServerRoleRequest || (GetServerRoleRequest = {}));
+/**
+ * Message implementation for ondewo.nlu.ListServerRolesRequest
+ */
+export class ListServerRolesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListServerRolesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.pageToken = _value.pageToken;
+        ListServerRolesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListServerRolesRequest();
+        ListServerRolesRequest.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.pageToken = _instance.pageToken || '';
+    }
+    /**
+     * 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.pageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListServerRolesRequest.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.pageToken) {
+            _writer.writeString(1, _instance.pageToken);
+        }
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListServerRolesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            pageToken: this.pageToken
+        };
+    }
+    /**
+     * 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 {
+            pageToken: this.pageToken
+        };
+    }
+}
+ListServerRolesRequest.id = 'ondewo.nlu.ListServerRolesRequest';
+/**
+ * Message implementation for ondewo.nlu.ListServerRolesResponse
+ */
+export class ListServerRolesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListServerRolesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.serverRoles = (_value.serverRoles || []).map(m => new ServerRole(m));
+        this.nextPageToken = _value.nextPageToken;
+        ListServerRolesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListServerRolesResponse();
+        ListServerRolesResponse.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.serverRoles = _instance.serverRoles || [];
+        _instance.nextPageToken = _instance.nextPageToken || '';
+    }
+    /**
+     * 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 ServerRole();
+                    _reader.readMessage(messageInitializer1, ServerRole.deserializeBinaryFromReader);
+                    (_instance.serverRoles = _instance.serverRoles || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListServerRolesResponse.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.serverRoles && _instance.serverRoles.length) {
+            _writer.writeRepeatedMessage(1, _instance.serverRoles, ServerRole.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    get serverRoles() {
+        return this._serverRoles;
+    }
+    set serverRoles(value) {
+        this._serverRoles = value;
+    }
+    get nextPageToken() {
+        return this._nextPageToken;
+    }
+    set nextPageToken(value) {
+        this._nextPageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListServerRolesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            serverRoles: (this.serverRoles || []).map(m => m.toObject()),
+            nextPageToken: this.nextPageToken
+        };
+    }
+    /**
+     * 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 {
+            serverRoles: (this.serverRoles || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+ListServerRolesResponse.id = 'ondewo.nlu.ListServerRolesResponse';
+/**
+ * Message implementation for ondewo.nlu.ListServerPermissionsRequest
+ */
+export class ListServerPermissionsRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListServerPermissionsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.pageToken = _value.pageToken;
+        ListServerPermissionsRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListServerPermissionsRequest();
+        ListServerPermissionsRequest.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.pageToken = _instance.pageToken || '';
+    }
+    /**
+     * 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.pageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListServerPermissionsRequest.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.pageToken) {
+            _writer.writeString(1, _instance.pageToken);
+        }
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListServerPermissionsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            pageToken: this.pageToken
+        };
+    }
+    /**
+     * 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 {
+            pageToken: this.pageToken
+        };
+    }
+}
+ListServerPermissionsRequest.id = 'ondewo.nlu.ListServerPermissionsRequest';
+/**
+ * Message implementation for ondewo.nlu.ListServerPermissionsResponse
+ */
+export class ListServerPermissionsResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListServerPermissionsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.permissions = (_value.permissions || []).slice();
+        this.nextPageToken = _value.nextPageToken;
+        ListServerPermissionsResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListServerPermissionsResponse();
+        ListServerPermissionsResponse.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.permissions = _instance.permissions || [];
+        _instance.nextPageToken = _instance.nextPageToken || '';
+    }
+    /**
+     * 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.permissions = _instance.permissions || []).push(_reader.readString());
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListServerPermissionsResponse.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.permissions && _instance.permissions.length) {
+            _writer.writeRepeatedString(1, _instance.permissions);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    get permissions() {
+        return this._permissions;
+    }
+    set permissions(value) {
+        this._permissions = value;
+    }
+    get nextPageToken() {
+        return this._nextPageToken;
+    }
+    set nextPageToken(value) {
+        this._nextPageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListServerPermissionsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            permissions: (this.permissions || []).slice(),
+            nextPageToken: this.nextPageToken
+        };
+    }
+    /**
+     * 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 {
+            permissions: (this.permissions || []).slice(),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+ListServerPermissionsResponse.id = 'ondewo.nlu.ListServerPermissionsResponse';
+/**
+ * Message implementation for ondewo.nlu.LoginRequest
+ */
+export class LoginRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of LoginRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.userEmail = _value.userEmail;
+        this.password = _value.password;
+        LoginRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new LoginRequest();
+        LoginRequest.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.userEmail = _instance.userEmail || '';
+        _instance.password = _instance.password || '';
+    }
+    /**
+     * 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.userEmail = _reader.readString();
+                    break;
+                case 2:
+                    _instance.password = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        LoginRequest.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.userEmail) {
+            _writer.writeString(1, _instance.userEmail);
+        }
+        if (_instance.password) {
+            _writer.writeString(2, _instance.password);
+        }
+    }
+    get userEmail() {
+        return this._userEmail;
+    }
+    set userEmail(value) {
+        this._userEmail = value;
+    }
+    get password() {
+        return this._password;
+    }
+    set password(value) {
+        this._password = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        LoginRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            userEmail: this.userEmail,
+            password: this.password
+        };
+    }
+    /**
+     * 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 {
+            userEmail: this.userEmail,
+            password: this.password
+        };
+    }
+}
+LoginRequest.id = 'ondewo.nlu.LoginRequest';
+/**
+ * Message implementation for ondewo.nlu.LoginResponse
+ */
+export class LoginResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of LoginResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.user = _value.user ? new User(_value.user) : undefined;
+        this.authToken = _value.authToken;
+        LoginResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new LoginResponse();
+        LoginResponse.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.user = _instance.user || undefined;
+        _instance.authToken = _instance.authToken || '';
+    }
+    /**
+     * 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.user = new User();
+                    _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.authToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        LoginResponse.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.user) {
+            _writer.writeMessage(1, _instance.user, User.serializeBinaryToWriter);
+        }
+        if (_instance.authToken) {
+            _writer.writeString(2, _instance.authToken);
+        }
+    }
+    get user() {
+        return this._user;
+    }
+    set user(value) {
+        this._user = value;
+    }
+    get authToken() {
+        return this._authToken;
+    }
+    set authToken(value) {
+        this._authToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        LoginResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            user: this.user ? this.user.toObject() : undefined,
+            authToken: this.authToken
+        };
+    }
+    /**
+     * 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 {
+            user: this.user ? this.user.toProtobufJSON(options) : null,
+            authToken: this.authToken
+        };
+    }
+}
+LoginResponse.id = 'ondewo.nlu.LoginResponse';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/user.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 googleApi000 from '../../google/api/http.pb';\nimport * as googleProtobuf001 from '@ngx-grpc/well-known-types';\nimport * as googleApi002 from '../../google/api/annotations.pb';\nimport * as googleProtobuf003 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf004 from '@ngx-grpc/well-known-types';\nimport * as ondewoNlu005 from '../../ondewo/nlu/project-role.pb';\nexport enum DefaultServerRole {\n  SERVER_UNSPECIFIED = 0,\n  SERVER_USER = 1,\n  SERVER_MANAGER = 2,\n  SERVER_ADMIN = 3,\n  SERVER_INACTIVE = 4\n}\n/**\n * Message implementation for ondewo.nlu.User\n */\nexport class User implements GrpcMessage {\n  static id = 'ondewo.nlu.User';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new User();\n    User.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: User) {\n    _instance.userId = _instance.userId || '';\n    _instance.displayName = _instance.displayName || '';\n    _instance.serverRoleId = _instance.serverRoleId || 0;\n    _instance.userEmail = _instance.userEmail || '';\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(_instance: User, _reader: BinaryReader) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 2:\n          _instance.userId = _reader.readString();\n          break;\n        case 3:\n          _instance.displayName = _reader.readString();\n          break;\n        case 6:\n          _instance.serverRoleId = _reader.readUint32();\n          break;\n        case 7:\n          _instance.userEmail = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    User.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: User, _writer: BinaryWriter) {\n    if (_instance.userId) {\n      _writer.writeString(2, _instance.userId);\n    }\n    if (_instance.displayName) {\n      _writer.writeString(3, _instance.displayName);\n    }\n    if (_instance.serverRoleId) {\n      _writer.writeUint32(6, _instance.serverRoleId);\n    }\n    if (_instance.userEmail) {\n      _writer.writeString(7, _instance.userEmail);\n    }\n  }\n\n  private _userId?: string;\n  private _displayName?: string;\n  private _serverRoleId?: number;\n  private _userEmail?: 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 User to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<User.AsObject>) {\n    _value = _value || {};\n    this.userId = _value.userId;\n    this.displayName = _value.displayName;\n    this.serverRoleId = _value.serverRoleId;\n    this.userEmail = _value.userEmail;\n    User.refineValues(this);\n  }\n  get userId(): string | undefined {\n    return this._userId;\n  }\n  set userId(value: string | undefined) {\n    this._userId = value;\n  }\n  get displayName(): string | undefined {\n    return this._displayName;\n  }\n  set displayName(value: string | undefined) {\n    this._displayName = value;\n  }\n  get serverRoleId(): number | undefined {\n    return this._serverRoleId;\n  }\n  set serverRoleId(value: number | undefined) {\n    this._serverRoleId = value;\n  }\n  get userEmail(): string | undefined {\n    return this._userEmail;\n  }\n  set userEmail(value: string | undefined) {\n    this._userEmail = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    User.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(): User.AsObject {\n    return {\n      userId: this.userId,\n      displayName: this.displayName,\n      serverRoleId: this.serverRoleId,\n      userEmail: this.userEmail\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  ): User.AsProtobufJSON {\n    return {\n      userId: this.userId,\n      displayName: this.displayName,\n      serverRoleId: this.serverRoleId,\n      userEmail: this.userEmail\n    };\n  }\n}\nexport module User {\n  /**\n   * Standard JavaScript object representation for User\n   */\n  export interface AsObject {\n    userId?: string;\n    displayName?: string;\n    serverRoleId?: number;\n    userEmail?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for User\n   */\n  export interface AsProtobufJSON {\n    userId?: string;\n    displayName?: string;\n    serverRoleId?: number;\n    userEmail?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.UserInfo\n */\nexport class UserInfo implements GrpcMessage {\n  static id = 'ondewo.nlu.UserInfo';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new UserInfo();\n    UserInfo.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: UserInfo) {\n    _instance.user = _instance.user || undefined;\n    _instance.projectRoles = _instance.projectRoles || {};\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: UserInfo,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.user = new User();\n          _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);\n          break;\n        case 2:\n          const msg_2 = {} as any;\n          _reader.readMessage(\n            msg_2,\n            UserInfo.ProjectRolesEntry.deserializeBinaryFromReader\n          );\n          _instance.projectRoles = _instance.projectRoles || {};\n          _instance.projectRoles[msg_2.key] = msg_2.value;\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    UserInfo.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: UserInfo, _writer: BinaryWriter) {\n    if (_instance.user) {\n      _writer.writeMessage(\n        1,\n        _instance.user as any,\n        User.serializeBinaryToWriter\n      );\n    }\n    if (!!_instance.projectRoles) {\n      const keys_2 = Object.keys(_instance.projectRoles as any);\n\n      if (keys_2.length) {\n        const repeated_2 = keys_2\n          .map(key => ({\n            key: key,\n            value: (_instance.projectRoles as any)[key]\n          }))\n          .reduce((r, v) => [...r, v], [] as any[]);\n\n        _writer.writeRepeatedMessage(\n          2,\n          repeated_2,\n          UserInfo.ProjectRolesEntry.serializeBinaryToWriter\n        );\n      }\n    }\n  }\n\n  private _user?: User;\n  private _projectRoles?: { [prop: string]: ondewoNlu005.ProjectRole };\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of UserInfo to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<UserInfo.AsObject>) {\n    _value = _value || {};\n    this.user = _value.user ? new User(_value.user) : undefined;\n    (this.projectRoles = _value!.projectRoles\n      ? Object.keys(_value!.projectRoles).reduce(\n          (r, k) => ({\n            ...r,\n            [k]: _value!.projectRoles![k]\n              ? new ondewoNlu005.ProjectRole(_value!.projectRoles![k])\n              : undefined\n          }),\n          {}\n        )\n      : {}),\n      UserInfo.refineValues(this);\n  }\n  get user(): User | undefined {\n    return this._user;\n  }\n  set user(value: User | undefined) {\n    this._user = value;\n  }\n  get projectRoles(): { [prop: string]: ondewoNlu005.ProjectRole } | undefined {\n    return this._projectRoles;\n  }\n  set projectRoles(\n    value: { [prop: string]: ondewoNlu005.ProjectRole } | undefined\n  ) {\n    this._projectRoles = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    UserInfo.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(): UserInfo.AsObject {\n    return {\n      user: this.user ? this.user.toObject() : undefined,\n      projectRoles: this.projectRoles\n        ? Object.keys(this.projectRoles).reduce(\n            (r, k) => ({\n              ...r,\n              [k]: this.projectRoles![k]\n                ? this.projectRoles![k].toObject()\n                : undefined\n            }),\n            {}\n          )\n        : {}\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  ): UserInfo.AsProtobufJSON {\n    return {\n      user: this.user ? this.user.toProtobufJSON(options) : null,\n      projectRoles: this.projectRoles\n        ? Object.keys(this.projectRoles).reduce(\n            (r, k) => ({\n              ...r,\n              [k]: this.projectRoles![k] ? this.projectRoles![k].toJSON() : null\n            }),\n            {}\n          )\n        : {}\n    };\n  }\n}\nexport module UserInfo {\n  /**\n   * Standard JavaScript object representation for UserInfo\n   */\n  export interface AsObject {\n    user?: User.AsObject;\n    projectRoles?: { [prop: string]: ondewoNlu005.ProjectRole };\n  }\n\n  /**\n   * Protobuf JSON representation for UserInfo\n   */\n  export interface AsProtobufJSON {\n    user?: User.AsProtobufJSON | null;\n    projectRoles?: { [prop: string]: ondewoNlu005.ProjectRole };\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.ProjectRolesEntry\n   */\n  export class ProjectRolesEntry implements GrpcMessage {\n    static id = 'ondewo.nlu.ProjectRolesEntry';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new ProjectRolesEntry();\n      ProjectRolesEntry.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: ProjectRolesEntry) {\n      _instance.key = _instance.key || '';\n      _instance.value = _instance.value || 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: ProjectRolesEntry,\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.value = new ondewoNlu005.ProjectRole();\n            _reader.readMessage(\n              _instance.value,\n              ondewoNlu005.ProjectRole.deserializeBinaryFromReader\n            );\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      ProjectRolesEntry.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: ProjectRolesEntry,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.key) {\n        _writer.writeString(1, _instance.key);\n      }\n      if (_instance.value) {\n        _writer.writeMessage(\n          2,\n          _instance.value as any,\n          ondewoNlu005.ProjectRole.serializeBinaryToWriter\n        );\n      }\n    }\n\n    private _key?: string;\n    private _value?: ondewoNlu005.ProjectRole;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of ProjectRolesEntry to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<ProjectRolesEntry.AsObject>) {\n      _value = _value || {};\n      this.key = _value.key;\n      this.value = _value.value\n        ? new ondewoNlu005.ProjectRole(_value.value)\n        : undefined;\n      ProjectRolesEntry.refineValues(this);\n    }\n    get key(): string | undefined {\n      return this._key;\n    }\n    set key(value: string | undefined) {\n      this._key = value;\n    }\n    get value(): ondewoNlu005.ProjectRole | undefined {\n      return this._value;\n    }\n    set value(value: ondewoNlu005.ProjectRole | undefined) {\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      ProjectRolesEntry.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(): ProjectRolesEntry.AsObject {\n      return {\n        key: this.key,\n        value: this.value ? this.value.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    ): ProjectRolesEntry.AsProtobufJSON {\n      return {\n        key: this.key,\n        value: this.value ? this.value.toProtobufJSON(options) : null\n      };\n    }\n  }\n  export module ProjectRolesEntry {\n    /**\n     * Standard JavaScript object representation for ProjectRolesEntry\n     */\n    export interface AsObject {\n      key?: string;\n      value?: ondewoNlu005.ProjectRole.AsObject;\n    }\n\n    /**\n     * Protobuf JSON representation for ProjectRolesEntry\n     */\n    export interface AsProtobufJSON {\n      key?: string;\n      value?: ondewoNlu005.ProjectRole.AsProtobufJSON | null;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CreateUserRequest\n */\nexport class CreateUserRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CreateUserRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CreateUserRequest();\n    CreateUserRequest.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: CreateUserRequest) {\n    _instance.user = _instance.user || undefined;\n    _instance.password = _instance.password || '';\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: CreateUserRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.user = new User();\n          _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);\n          break;\n        case 3:\n          _instance.password = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CreateUserRequest.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: CreateUserRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.user) {\n      _writer.writeMessage(\n        1,\n        _instance.user as any,\n        User.serializeBinaryToWriter\n      );\n    }\n    if (_instance.password) {\n      _writer.writeString(3, _instance.password);\n    }\n  }\n\n  private _user?: User;\n  private _password?: 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 CreateUserRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CreateUserRequest.AsObject>) {\n    _value = _value || {};\n    this.user = _value.user ? new User(_value.user) : undefined;\n    this.password = _value.password;\n    CreateUserRequest.refineValues(this);\n  }\n  get user(): User | undefined {\n    return this._user;\n  }\n  set user(value: User | undefined) {\n    this._user = value;\n  }\n  get password(): string | undefined {\n    return this._password;\n  }\n  set password(value: string | undefined) {\n    this._password = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CreateUserRequest.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(): CreateUserRequest.AsObject {\n    return {\n      user: this.user ? this.user.toObject() : undefined,\n      password: this.password\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  ): CreateUserRequest.AsProtobufJSON {\n    return {\n      user: this.user ? this.user.toProtobufJSON(options) : null,\n      password: this.password\n    };\n  }\n}\nexport module CreateUserRequest {\n  /**\n   * Standard JavaScript object representation for CreateUserRequest\n   */\n  export interface AsObject {\n    user?: User.AsObject;\n    password?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for CreateUserRequest\n   */\n  export interface AsProtobufJSON {\n    user?: User.AsProtobufJSON | null;\n    password?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.UpdateUserRequest\n */\nexport class UpdateUserRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.UpdateUserRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new UpdateUserRequest();\n    UpdateUserRequest.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: UpdateUserRequest) {\n    _instance.user = _instance.user || undefined;\n    _instance.password = _instance.password || '';\n    _instance.updateMask = _instance.updateMask || 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: UpdateUserRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.user = new User();\n          _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);\n          break;\n        case 4:\n          _instance.password = _reader.readString();\n          break;\n        case 5:\n          _instance.updateMask = new googleProtobuf003.FieldMask();\n          _reader.readMessage(\n            _instance.updateMask,\n            googleProtobuf003.FieldMask.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    UpdateUserRequest.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: UpdateUserRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.user) {\n      _writer.writeMessage(\n        1,\n        _instance.user as any,\n        User.serializeBinaryToWriter\n      );\n    }\n    if (_instance.password) {\n      _writer.writeString(4, _instance.password);\n    }\n    if (_instance.updateMask) {\n      _writer.writeMessage(\n        5,\n        _instance.updateMask as any,\n        googleProtobuf003.FieldMask.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _user?: User;\n  private _password?: string;\n  private _updateMask?: googleProtobuf003.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 UpdateUserRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<UpdateUserRequest.AsObject>) {\n    _value = _value || {};\n    this.user = _value.user ? new User(_value.user) : undefined;\n    this.password = _value.password;\n    this.updateMask = _value.updateMask\n      ? new googleProtobuf003.FieldMask(_value.updateMask)\n      : undefined;\n    UpdateUserRequest.refineValues(this);\n  }\n  get user(): User | undefined {\n    return this._user;\n  }\n  set user(value: User | undefined) {\n    this._user = value;\n  }\n  get password(): string | undefined {\n    return this._password;\n  }\n  set password(value: string | undefined) {\n    this._password = value;\n  }\n  get updateMask(): googleProtobuf003.FieldMask | undefined {\n    return this._updateMask;\n  }\n  set updateMask(value: googleProtobuf003.FieldMask | undefined) {\n    this._updateMask = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    UpdateUserRequest.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(): UpdateUserRequest.AsObject {\n    return {\n      user: this.user ? this.user.toObject() : undefined,\n      password: this.password,\n      updateMask: this.updateMask ? this.updateMask.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  ): UpdateUserRequest.AsProtobufJSON {\n    return {\n      user: this.user ? this.user.toProtobufJSON(options) : null,\n      password: this.password,\n      updateMask: this.updateMask\n        ? this.updateMask.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module UpdateUserRequest {\n  /**\n   * Standard JavaScript object representation for UpdateUserRequest\n   */\n  export interface AsObject {\n    user?: User.AsObject;\n    password?: string;\n    updateMask?: googleProtobuf003.FieldMask.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for UpdateUserRequest\n   */\n  export interface AsProtobufJSON {\n    user?: User.AsProtobufJSON | null;\n    password?: string;\n    updateMask?: googleProtobuf003.FieldMask.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetUserRequest\n */\nexport class GetUserRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetUserRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetUserRequest();\n    GetUserRequest.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: GetUserRequest) {}\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: GetUserRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.userId = _reader.readString();\n          break;\n        case 3:\n          _instance.userEmail = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetUserRequest.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: GetUserRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.userId || _instance.userId === '') {\n      _writer.writeString(1, _instance.userId);\n    }\n    if (_instance.userEmail || _instance.userEmail === '') {\n      _writer.writeString(3, _instance.userEmail);\n    }\n  }\n\n  private _userId?: string;\n  private _userEmail?: string;\n\n  private _userIdentifier: GetUserRequest.UserIdentifierCase =\n    GetUserRequest.UserIdentifierCase.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 GetUserRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetUserRequest.AsObject>) {\n    _value = _value || {};\n    this.userId = _value.userId;\n    this.userEmail = _value.userEmail;\n    GetUserRequest.refineValues(this);\n  }\n  get userId(): string | undefined {\n    return this._userId;\n  }\n  set userId(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._userEmail = undefined;\n      this._userIdentifier = GetUserRequest.UserIdentifierCase.userId;\n    }\n    this._userId = value;\n  }\n  get userEmail(): string | undefined {\n    return this._userEmail;\n  }\n  set userEmail(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._userId = undefined;\n      this._userIdentifier = GetUserRequest.UserIdentifierCase.userEmail;\n    }\n    this._userEmail = value;\n  }\n  get userIdentifier() {\n    return this._userIdentifier;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetUserRequest.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(): GetUserRequest.AsObject {\n    return {\n      userId: this.userId,\n      userEmail: this.userEmail\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  ): GetUserRequest.AsProtobufJSON {\n    return {\n      userId:\n        this.userId === null || this.userId === undefined ? null : this.userId,\n      userEmail:\n        this.userEmail === null || this.userEmail === undefined\n          ? null\n          : this.userEmail\n    };\n  }\n}\nexport module GetUserRequest {\n  /**\n   * Standard JavaScript object representation for GetUserRequest\n   */\n  export interface AsObject {\n    userId?: string;\n    userEmail?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetUserRequest\n   */\n  export interface AsProtobufJSON {\n    userId?: string | null;\n    userEmail?: string | null;\n  }\n  export enum UserIdentifierCase {\n    none = 0,\n    userId = 1,\n    userEmail = 2\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.DeleteUserRequest\n */\nexport class DeleteUserRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.DeleteUserRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new DeleteUserRequest();\n    DeleteUserRequest.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: DeleteUserRequest) {\n    _instance.userId = _instance.userId || '';\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: DeleteUserRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.userId = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    DeleteUserRequest.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: DeleteUserRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.userId) {\n      _writer.writeString(1, _instance.userId);\n    }\n  }\n\n  private _userId?: 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 DeleteUserRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<DeleteUserRequest.AsObject>) {\n    _value = _value || {};\n    this.userId = _value.userId;\n    DeleteUserRequest.refineValues(this);\n  }\n  get userId(): string | undefined {\n    return this._userId;\n  }\n  set userId(value: string | undefined) {\n    this._userId = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    DeleteUserRequest.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(): DeleteUserRequest.AsObject {\n    return {\n      userId: this.userId\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  ): DeleteUserRequest.AsProtobufJSON {\n    return {\n      userId: this.userId\n    };\n  }\n}\nexport module DeleteUserRequest {\n  /**\n   * Standard JavaScript object representation for DeleteUserRequest\n   */\n  export interface AsObject {\n    userId?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for DeleteUserRequest\n   */\n  export interface AsProtobufJSON {\n    userId?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListUsersRequest\n */\nexport class ListUsersRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListUsersRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListUsersRequest();\n    ListUsersRequest.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: ListUsersRequest) {\n    _instance.pageToken = _instance.pageToken || '';\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: ListUsersRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.pageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListUsersRequest.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: ListUsersRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.pageToken) {\n      _writer.writeString(1, _instance.pageToken);\n    }\n  }\n\n  private _pageToken?: 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 ListUsersRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListUsersRequest.AsObject>) {\n    _value = _value || {};\n    this.pageToken = _value.pageToken;\n    ListUsersRequest.refineValues(this);\n  }\n  get pageToken(): string | undefined {\n    return this._pageToken;\n  }\n  set pageToken(value: string | undefined) {\n    this._pageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListUsersRequest.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(): ListUsersRequest.AsObject {\n    return {\n      pageToken: this.pageToken\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  ): ListUsersRequest.AsProtobufJSON {\n    return {\n      pageToken: this.pageToken\n    };\n  }\n}\nexport module ListUsersRequest {\n  /**\n   * Standard JavaScript object representation for ListUsersRequest\n   */\n  export interface AsObject {\n    pageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListUsersRequest\n   */\n  export interface AsProtobufJSON {\n    pageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListUsersResponse\n */\nexport class ListUsersResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListUsersResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListUsersResponse();\n    ListUsersResponse.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: ListUsersResponse) {\n    _instance.users = _instance.users || [];\n    _instance.nextPageToken = _instance.nextPageToken || '';\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: ListUsersResponse,\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 User();\n          _reader.readMessage(\n            messageInitializer1,\n            User.deserializeBinaryFromReader\n          );\n          (_instance.users = _instance.users || []).push(messageInitializer1);\n          break;\n        case 2:\n          _instance.nextPageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListUsersResponse.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: ListUsersResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.users && _instance.users.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.users as any,\n        User.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _users?: User[];\n  private _nextPageToken?: 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 ListUsersResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListUsersResponse.AsObject>) {\n    _value = _value || {};\n    this.users = (_value.users || []).map(m => new User(m));\n    this.nextPageToken = _value.nextPageToken;\n    ListUsersResponse.refineValues(this);\n  }\n  get users(): User[] | undefined {\n    return this._users;\n  }\n  set users(value: User[] | undefined) {\n    this._users = value;\n  }\n  get nextPageToken(): string | undefined {\n    return this._nextPageToken;\n  }\n  set nextPageToken(value: string | undefined) {\n    this._nextPageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListUsersResponse.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(): ListUsersResponse.AsObject {\n    return {\n      users: (this.users || []).map(m => m.toObject()),\n      nextPageToken: this.nextPageToken\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  ): ListUsersResponse.AsProtobufJSON {\n    return {\n      users: (this.users || []).map(m => m.toProtobufJSON(options)),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListUsersResponse {\n  /**\n   * Standard JavaScript object representation for ListUsersResponse\n   */\n  export interface AsObject {\n    users?: User.AsObject[];\n    nextPageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListUsersResponse\n   */\n  export interface AsProtobufJSON {\n    users?: User.AsProtobufJSON[] | null;\n    nextPageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListUserInfosResponse\n */\nexport class ListUserInfosResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListUserInfosResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListUserInfosResponse();\n    ListUserInfosResponse.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: ListUserInfosResponse) {\n    _instance.users = _instance.users || [];\n    _instance.nextPageToken = _instance.nextPageToken || '';\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: ListUserInfosResponse,\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 UserInfo();\n          _reader.readMessage(\n            messageInitializer1,\n            UserInfo.deserializeBinaryFromReader\n          );\n          (_instance.users = _instance.users || []).push(messageInitializer1);\n          break;\n        case 2:\n          _instance.nextPageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListUserInfosResponse.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: ListUserInfosResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.users && _instance.users.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.users as any,\n        UserInfo.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _users?: UserInfo[];\n  private _nextPageToken?: 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 ListUserInfosResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListUserInfosResponse.AsObject>) {\n    _value = _value || {};\n    this.users = (_value.users || []).map(m => new UserInfo(m));\n    this.nextPageToken = _value.nextPageToken;\n    ListUserInfosResponse.refineValues(this);\n  }\n  get users(): UserInfo[] | undefined {\n    return this._users;\n  }\n  set users(value: UserInfo[] | undefined) {\n    this._users = value;\n  }\n  get nextPageToken(): string | undefined {\n    return this._nextPageToken;\n  }\n  set nextPageToken(value: string | undefined) {\n    this._nextPageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListUserInfosResponse.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(): ListUserInfosResponse.AsObject {\n    return {\n      users: (this.users || []).map(m => m.toObject()),\n      nextPageToken: this.nextPageToken\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  ): ListUserInfosResponse.AsProtobufJSON {\n    return {\n      users: (this.users || []).map(m => m.toProtobufJSON(options)),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListUserInfosResponse {\n  /**\n   * Standard JavaScript object representation for ListUserInfosResponse\n   */\n  export interface AsObject {\n    users?: UserInfo.AsObject[];\n    nextPageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListUserInfosResponse\n   */\n  export interface AsProtobufJSON {\n    users?: UserInfo.AsProtobufJSON[] | null;\n    nextPageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ServerRole\n */\nexport class ServerRole implements GrpcMessage {\n  static id = 'ondewo.nlu.ServerRole';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ServerRole();\n    ServerRole.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: ServerRole) {\n    _instance.roleId = _instance.roleId || 0;\n    _instance.name = _instance.name || '';\n    _instance.permissions = _instance.permissions || [];\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: ServerRole,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.roleId = _reader.readUint32();\n          break;\n        case 2:\n          _instance.name = _reader.readString();\n          break;\n        case 3:\n          (_instance.permissions = _instance.permissions || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ServerRole.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: ServerRole, _writer: BinaryWriter) {\n    if (_instance.roleId) {\n      _writer.writeUint32(1, _instance.roleId);\n    }\n    if (_instance.name) {\n      _writer.writeString(2, _instance.name);\n    }\n    if (_instance.permissions && _instance.permissions.length) {\n      _writer.writeRepeatedString(3, _instance.permissions);\n    }\n  }\n\n  private _roleId?: number;\n  private _name?: string;\n  private _permissions?: 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 ServerRole to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ServerRole.AsObject>) {\n    _value = _value || {};\n    this.roleId = _value.roleId;\n    this.name = _value.name;\n    this.permissions = (_value.permissions || []).slice();\n    ServerRole.refineValues(this);\n  }\n  get roleId(): number | undefined {\n    return this._roleId;\n  }\n  set roleId(value: number | undefined) {\n    this._roleId = value;\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n  get permissions(): string[] | undefined {\n    return this._permissions;\n  }\n  set permissions(value: string[] | undefined) {\n    this._permissions = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ServerRole.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(): ServerRole.AsObject {\n    return {\n      roleId: this.roleId,\n      name: this.name,\n      permissions: (this.permissions || []).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  ): ServerRole.AsProtobufJSON {\n    return {\n      roleId: this.roleId,\n      name: this.name,\n      permissions: (this.permissions || []).slice()\n    };\n  }\n}\nexport module ServerRole {\n  /**\n   * Standard JavaScript object representation for ServerRole\n   */\n  export interface AsObject {\n    roleId?: number;\n    name?: string;\n    permissions?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for ServerRole\n   */\n  export interface AsProtobufJSON {\n    roleId?: number;\n    name?: string;\n    permissions?: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CreateServerRoleRequest\n */\nexport class CreateServerRoleRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CreateServerRoleRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CreateServerRoleRequest();\n    CreateServerRoleRequest.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: CreateServerRoleRequest) {\n    _instance.role = _instance.role || 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: CreateServerRoleRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.role = new ServerRole();\n          _reader.readMessage(\n            _instance.role,\n            ServerRole.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CreateServerRoleRequest.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: CreateServerRoleRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.role) {\n      _writer.writeMessage(\n        1,\n        _instance.role as any,\n        ServerRole.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _role?: ServerRole;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CreateServerRoleRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CreateServerRoleRequest.AsObject>) {\n    _value = _value || {};\n    this.role = _value.role ? new ServerRole(_value.role) : undefined;\n    CreateServerRoleRequest.refineValues(this);\n  }\n  get role(): ServerRole | undefined {\n    return this._role;\n  }\n  set role(value: ServerRole | undefined) {\n    this._role = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CreateServerRoleRequest.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(): CreateServerRoleRequest.AsObject {\n    return {\n      role: this.role ? this.role.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  ): CreateServerRoleRequest.AsProtobufJSON {\n    return {\n      role: this.role ? this.role.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module CreateServerRoleRequest {\n  /**\n   * Standard JavaScript object representation for CreateServerRoleRequest\n   */\n  export interface AsObject {\n    role?: ServerRole.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for CreateServerRoleRequest\n   */\n  export interface AsProtobufJSON {\n    role?: ServerRole.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.UpdateServerRoleRequest\n */\nexport class UpdateServerRoleRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.UpdateServerRoleRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new UpdateServerRoleRequest();\n    UpdateServerRoleRequest.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: UpdateServerRoleRequest) {\n    _instance.role = _instance.role || undefined;\n    _instance.updateMask = _instance.updateMask || 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: UpdateServerRoleRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.role = new ServerRole();\n          _reader.readMessage(\n            _instance.role,\n            ServerRole.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.updateMask = new googleProtobuf003.FieldMask();\n          _reader.readMessage(\n            _instance.updateMask,\n            googleProtobuf003.FieldMask.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    UpdateServerRoleRequest.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: UpdateServerRoleRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.role) {\n      _writer.writeMessage(\n        1,\n        _instance.role as any,\n        ServerRole.serializeBinaryToWriter\n      );\n    }\n    if (_instance.updateMask) {\n      _writer.writeMessage(\n        2,\n        _instance.updateMask as any,\n        googleProtobuf003.FieldMask.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _role?: ServerRole;\n  private _updateMask?: googleProtobuf003.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 UpdateServerRoleRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<UpdateServerRoleRequest.AsObject>) {\n    _value = _value || {};\n    this.role = _value.role ? new ServerRole(_value.role) : undefined;\n    this.updateMask = _value.updateMask\n      ? new googleProtobuf003.FieldMask(_value.updateMask)\n      : undefined;\n    UpdateServerRoleRequest.refineValues(this);\n  }\n  get role(): ServerRole | undefined {\n    return this._role;\n  }\n  set role(value: ServerRole | undefined) {\n    this._role = value;\n  }\n  get updateMask(): googleProtobuf003.FieldMask | undefined {\n    return this._updateMask;\n  }\n  set updateMask(value: googleProtobuf003.FieldMask | undefined) {\n    this._updateMask = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    UpdateServerRoleRequest.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(): UpdateServerRoleRequest.AsObject {\n    return {\n      role: this.role ? this.role.toObject() : undefined,\n      updateMask: this.updateMask ? this.updateMask.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  ): UpdateServerRoleRequest.AsProtobufJSON {\n    return {\n      role: this.role ? this.role.toProtobufJSON(options) : null,\n      updateMask: this.updateMask\n        ? this.updateMask.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module UpdateServerRoleRequest {\n  /**\n   * Standard JavaScript object representation for UpdateServerRoleRequest\n   */\n  export interface AsObject {\n    role?: ServerRole.AsObject;\n    updateMask?: googleProtobuf003.FieldMask.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for UpdateServerRoleRequest\n   */\n  export interface AsProtobufJSON {\n    role?: ServerRole.AsProtobufJSON | null;\n    updateMask?: googleProtobuf003.FieldMask.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.DeleteServerRoleRequest\n */\nexport class DeleteServerRoleRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.DeleteServerRoleRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new DeleteServerRoleRequest();\n    DeleteServerRoleRequest.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: DeleteServerRoleRequest) {\n    _instance.roleId = _instance.roleId || 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: DeleteServerRoleRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.roleId = _reader.readUint32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    DeleteServerRoleRequest.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: DeleteServerRoleRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.roleId) {\n      _writer.writeUint32(1, _instance.roleId);\n    }\n  }\n\n  private _roleId?: 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 DeleteServerRoleRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<DeleteServerRoleRequest.AsObject>) {\n    _value = _value || {};\n    this.roleId = _value.roleId;\n    DeleteServerRoleRequest.refineValues(this);\n  }\n  get roleId(): number | undefined {\n    return this._roleId;\n  }\n  set roleId(value: number | undefined) {\n    this._roleId = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    DeleteServerRoleRequest.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(): DeleteServerRoleRequest.AsObject {\n    return {\n      roleId: this.roleId\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  ): DeleteServerRoleRequest.AsProtobufJSON {\n    return {\n      roleId: this.roleId\n    };\n  }\n}\nexport module DeleteServerRoleRequest {\n  /**\n   * Standard JavaScript object representation for DeleteServerRoleRequest\n   */\n  export interface AsObject {\n    roleId?: number;\n  }\n\n  /**\n   * Protobuf JSON representation for DeleteServerRoleRequest\n   */\n  export interface AsProtobufJSON {\n    roleId?: number;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetServerRoleRequest\n */\nexport class GetServerRoleRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetServerRoleRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetServerRoleRequest();\n    GetServerRoleRequest.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: GetServerRoleRequest) {}\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: GetServerRoleRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.roleId = _reader.readUint32();\n          break;\n        case 2:\n          _instance.roleName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetServerRoleRequest.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: GetServerRoleRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.roleId || _instance.roleId === 0) {\n      _writer.writeUint32(1, _instance.roleId);\n    }\n    if (_instance.roleName || _instance.roleName === '') {\n      _writer.writeString(2, _instance.roleName);\n    }\n  }\n\n  private _roleId?: number;\n  private _roleName?: string;\n\n  private _serverRoleIdentifier: GetServerRoleRequest.ServerRoleIdentifierCase =\n    GetServerRoleRequest.ServerRoleIdentifierCase.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 GetServerRoleRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetServerRoleRequest.AsObject>) {\n    _value = _value || {};\n    this.roleId = _value.roleId;\n    this.roleName = _value.roleName;\n    GetServerRoleRequest.refineValues(this);\n  }\n  get roleId(): number | undefined {\n    return this._roleId;\n  }\n  set roleId(value: number | undefined) {\n    if (value !== undefined && value !== null) {\n      this._roleName = undefined;\n      this._serverRoleIdentifier =\n        GetServerRoleRequest.ServerRoleIdentifierCase.roleId;\n    }\n    this._roleId = value;\n  }\n  get roleName(): string | undefined {\n    return this._roleName;\n  }\n  set roleName(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._roleId = undefined;\n      this._serverRoleIdentifier =\n        GetServerRoleRequest.ServerRoleIdentifierCase.roleName;\n    }\n    this._roleName = value;\n  }\n  get serverRoleIdentifier() {\n    return this._serverRoleIdentifier;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetServerRoleRequest.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(): GetServerRoleRequest.AsObject {\n    return {\n      roleId: this.roleId,\n      roleName: this.roleName\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  ): GetServerRoleRequest.AsProtobufJSON {\n    return {\n      roleId:\n        this.roleId === null || this.roleId === undefined ? null : this.roleId,\n      roleName:\n        this.roleName === null || this.roleName === undefined\n          ? null\n          : this.roleName\n    };\n  }\n}\nexport module GetServerRoleRequest {\n  /**\n   * Standard JavaScript object representation for GetServerRoleRequest\n   */\n  export interface AsObject {\n    roleId?: number;\n    roleName?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetServerRoleRequest\n   */\n  export interface AsProtobufJSON {\n    roleId?: number | null;\n    roleName?: string | null;\n  }\n  export enum ServerRoleIdentifierCase {\n    none = 0,\n    roleId = 1,\n    roleName = 2\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListServerRolesRequest\n */\nexport class ListServerRolesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListServerRolesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListServerRolesRequest();\n    ListServerRolesRequest.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: ListServerRolesRequest) {\n    _instance.pageToken = _instance.pageToken || '';\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: ListServerRolesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.pageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListServerRolesRequest.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: ListServerRolesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.pageToken) {\n      _writer.writeString(1, _instance.pageToken);\n    }\n  }\n\n  private _pageToken?: 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 ListServerRolesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListServerRolesRequest.AsObject>) {\n    _value = _value || {};\n    this.pageToken = _value.pageToken;\n    ListServerRolesRequest.refineValues(this);\n  }\n  get pageToken(): string | undefined {\n    return this._pageToken;\n  }\n  set pageToken(value: string | undefined) {\n    this._pageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListServerRolesRequest.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(): ListServerRolesRequest.AsObject {\n    return {\n      pageToken: this.pageToken\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  ): ListServerRolesRequest.AsProtobufJSON {\n    return {\n      pageToken: this.pageToken\n    };\n  }\n}\nexport module ListServerRolesRequest {\n  /**\n   * Standard JavaScript object representation for ListServerRolesRequest\n   */\n  export interface AsObject {\n    pageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListServerRolesRequest\n   */\n  export interface AsProtobufJSON {\n    pageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListServerRolesResponse\n */\nexport class ListServerRolesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListServerRolesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListServerRolesResponse();\n    ListServerRolesResponse.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: ListServerRolesResponse) {\n    _instance.serverRoles = _instance.serverRoles || [];\n    _instance.nextPageToken = _instance.nextPageToken || '';\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: ListServerRolesResponse,\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 ServerRole();\n          _reader.readMessage(\n            messageInitializer1,\n            ServerRole.deserializeBinaryFromReader\n          );\n          (_instance.serverRoles = _instance.serverRoles || []).push(\n            messageInitializer1\n          );\n          break;\n        case 2:\n          _instance.nextPageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListServerRolesResponse.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: ListServerRolesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.serverRoles && _instance.serverRoles.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.serverRoles as any,\n        ServerRole.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _serverRoles?: ServerRole[];\n  private _nextPageToken?: 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 ListServerRolesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListServerRolesResponse.AsObject>) {\n    _value = _value || {};\n    this.serverRoles = (_value.serverRoles || []).map(m => new ServerRole(m));\n    this.nextPageToken = _value.nextPageToken;\n    ListServerRolesResponse.refineValues(this);\n  }\n  get serverRoles(): ServerRole[] | undefined {\n    return this._serverRoles;\n  }\n  set serverRoles(value: ServerRole[] | undefined) {\n    this._serverRoles = value;\n  }\n  get nextPageToken(): string | undefined {\n    return this._nextPageToken;\n  }\n  set nextPageToken(value: string | undefined) {\n    this._nextPageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListServerRolesResponse.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(): ListServerRolesResponse.AsObject {\n    return {\n      serverRoles: (this.serverRoles || []).map(m => m.toObject()),\n      nextPageToken: this.nextPageToken\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  ): ListServerRolesResponse.AsProtobufJSON {\n    return {\n      serverRoles: (this.serverRoles || []).map(m => m.toProtobufJSON(options)),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListServerRolesResponse {\n  /**\n   * Standard JavaScript object representation for ListServerRolesResponse\n   */\n  export interface AsObject {\n    serverRoles?: ServerRole.AsObject[];\n    nextPageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListServerRolesResponse\n   */\n  export interface AsProtobufJSON {\n    serverRoles?: ServerRole.AsProtobufJSON[] | null;\n    nextPageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListServerPermissionsRequest\n */\nexport class ListServerPermissionsRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListServerPermissionsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListServerPermissionsRequest();\n    ListServerPermissionsRequest.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: ListServerPermissionsRequest) {\n    _instance.pageToken = _instance.pageToken || '';\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: ListServerPermissionsRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.pageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListServerPermissionsRequest.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: ListServerPermissionsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.pageToken) {\n      _writer.writeString(1, _instance.pageToken);\n    }\n  }\n\n  private _pageToken?: 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 ListServerPermissionsRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<ListServerPermissionsRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.pageToken = _value.pageToken;\n    ListServerPermissionsRequest.refineValues(this);\n  }\n  get pageToken(): string | undefined {\n    return this._pageToken;\n  }\n  set pageToken(value: string | undefined) {\n    this._pageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListServerPermissionsRequest.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(): ListServerPermissionsRequest.AsObject {\n    return {\n      pageToken: this.pageToken\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  ): ListServerPermissionsRequest.AsProtobufJSON {\n    return {\n      pageToken: this.pageToken\n    };\n  }\n}\nexport module ListServerPermissionsRequest {\n  /**\n   * Standard JavaScript object representation for ListServerPermissionsRequest\n   */\n  export interface AsObject {\n    pageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListServerPermissionsRequest\n   */\n  export interface AsProtobufJSON {\n    pageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListServerPermissionsResponse\n */\nexport class ListServerPermissionsResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListServerPermissionsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListServerPermissionsResponse();\n    ListServerPermissionsResponse.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: ListServerPermissionsResponse) {\n    _instance.permissions = _instance.permissions || [];\n    _instance.nextPageToken = _instance.nextPageToken || '';\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: ListServerPermissionsResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.permissions = _instance.permissions || []).push(\n            _reader.readString()\n          );\n          break;\n        case 2:\n          _instance.nextPageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListServerPermissionsResponse.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: ListServerPermissionsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.permissions && _instance.permissions.length) {\n      _writer.writeRepeatedString(1, _instance.permissions);\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _permissions?: string[];\n  private _nextPageToken?: 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 ListServerPermissionsResponse to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<ListServerPermissionsResponse.AsObject>\n  ) {\n    _value = _value || {};\n    this.permissions = (_value.permissions || []).slice();\n    this.nextPageToken = _value.nextPageToken;\n    ListServerPermissionsResponse.refineValues(this);\n  }\n  get permissions(): string[] | undefined {\n    return this._permissions;\n  }\n  set permissions(value: string[] | undefined) {\n    this._permissions = value;\n  }\n  get nextPageToken(): string | undefined {\n    return this._nextPageToken;\n  }\n  set nextPageToken(value: string | undefined) {\n    this._nextPageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListServerPermissionsResponse.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(): ListServerPermissionsResponse.AsObject {\n    return {\n      permissions: (this.permissions || []).slice(),\n      nextPageToken: this.nextPageToken\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  ): ListServerPermissionsResponse.AsProtobufJSON {\n    return {\n      permissions: (this.permissions || []).slice(),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListServerPermissionsResponse {\n  /**\n   * Standard JavaScript object representation for ListServerPermissionsResponse\n   */\n  export interface AsObject {\n    permissions?: string[];\n    nextPageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListServerPermissionsResponse\n   */\n  export interface AsProtobufJSON {\n    permissions?: string[];\n    nextPageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.LoginRequest\n */\nexport class LoginRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.LoginRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new LoginRequest();\n    LoginRequest.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: LoginRequest) {\n    _instance.userEmail = _instance.userEmail || '';\n    _instance.password = _instance.password || '';\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: LoginRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.userEmail = _reader.readString();\n          break;\n        case 2:\n          _instance.password = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    LoginRequest.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: LoginRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.userEmail) {\n      _writer.writeString(1, _instance.userEmail);\n    }\n    if (_instance.password) {\n      _writer.writeString(2, _instance.password);\n    }\n  }\n\n  private _userEmail?: string;\n  private _password?: 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 LoginRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<LoginRequest.AsObject>) {\n    _value = _value || {};\n    this.userEmail = _value.userEmail;\n    this.password = _value.password;\n    LoginRequest.refineValues(this);\n  }\n  get userEmail(): string | undefined {\n    return this._userEmail;\n  }\n  set userEmail(value: string | undefined) {\n    this._userEmail = value;\n  }\n  get password(): string | undefined {\n    return this._password;\n  }\n  set password(value: string | undefined) {\n    this._password = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    LoginRequest.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(): LoginRequest.AsObject {\n    return {\n      userEmail: this.userEmail,\n      password: this.password\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  ): LoginRequest.AsProtobufJSON {\n    return {\n      userEmail: this.userEmail,\n      password: this.password\n    };\n  }\n}\nexport module LoginRequest {\n  /**\n   * Standard JavaScript object representation for LoginRequest\n   */\n  export interface AsObject {\n    userEmail?: string;\n    password?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for LoginRequest\n   */\n  export interface AsProtobufJSON {\n    userEmail?: string;\n    password?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.LoginResponse\n */\nexport class LoginResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.LoginResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new LoginResponse();\n    LoginResponse.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: LoginResponse) {\n    _instance.user = _instance.user || undefined;\n    _instance.authToken = _instance.authToken || '';\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: LoginResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.user = new User();\n          _reader.readMessage(_instance.user, User.deserializeBinaryFromReader);\n          break;\n        case 2:\n          _instance.authToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    LoginResponse.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: LoginResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.user) {\n      _writer.writeMessage(\n        1,\n        _instance.user as any,\n        User.serializeBinaryToWriter\n      );\n    }\n    if (_instance.authToken) {\n      _writer.writeString(2, _instance.authToken);\n    }\n  }\n\n  private _user?: User;\n  private _authToken?: 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 LoginResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<LoginResponse.AsObject>) {\n    _value = _value || {};\n    this.user = _value.user ? new User(_value.user) : undefined;\n    this.authToken = _value.authToken;\n    LoginResponse.refineValues(this);\n  }\n  get user(): User | undefined {\n    return this._user;\n  }\n  set user(value: User | undefined) {\n    this._user = value;\n  }\n  get authToken(): string | undefined {\n    return this._authToken;\n  }\n  set authToken(value: string | undefined) {\n    this._authToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    LoginResponse.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(): LoginResponse.AsObject {\n    return {\n      user: this.user ? this.user.toObject() : undefined,\n      authToken: this.authToken\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  ): LoginResponse.AsProtobufJSON {\n    return {\n      user: this.user ? this.user.toProtobufJSON(options) : null,\n      authToken: this.authToken\n    };\n  }\n}\nexport module LoginResponse {\n  /**\n   * Standard JavaScript object representation for LoginResponse\n   */\n  export interface AsObject {\n    user?: User.AsObject;\n    authToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for LoginResponse\n   */\n  export interface AsProtobufJSON {\n    user?: User.AsProtobufJSON | null;\n    authToken?: string;\n  }\n}\n"]}