@ondewo/csi-client-angular 2.3.1

package/esm2020/api/ondewo/nlu/entity-type.pb.mjs

@@ -0,0 +1,3466 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf004 from '@ngx-grpc/well-known-types';
+import * as googleProtobuf008 from '@ngx-grpc/well-known-types';
+import * as ondewoNlu009 from '../../ondewo/nlu/common.pb';
+export var EntityTypeView;
+(function (EntityTypeView) {
+    EntityTypeView[EntityTypeView["ENTITY_TYPE_VIEW_UNSPECIFIED"] = 0] = "ENTITY_TYPE_VIEW_UNSPECIFIED";
+    EntityTypeView[EntityTypeView["ENTITY_TYPE_VIEW_FULL"] = 1] = "ENTITY_TYPE_VIEW_FULL";
+    EntityTypeView[EntityTypeView["ENTITY_TYPE_VIEW_PARTIAL"] = 2] = "ENTITY_TYPE_VIEW_PARTIAL";
+    EntityTypeView[EntityTypeView["ENTITY_TYPE_VIEW_SHALLOW"] = 3] = "ENTITY_TYPE_VIEW_SHALLOW";
+})(EntityTypeView || (EntityTypeView = {}));
+export var EntityTypeCategory;
+(function (EntityTypeCategory) {
+    EntityTypeCategory[EntityTypeCategory["ALL_ENTITY_TYPES"] = 0] = "ALL_ENTITY_TYPES";
+    EntityTypeCategory[EntityTypeCategory["DEFAULT_ENTITY_TYPES"] = 1] = "DEFAULT_ENTITY_TYPES";
+    EntityTypeCategory[EntityTypeCategory["USER_DEFINED_ENTITY_TYPES"] = 2] = "USER_DEFINED_ENTITY_TYPES";
+})(EntityTypeCategory || (EntityTypeCategory = {}));
+/**
+ * Message implementation for ondewo.nlu.EntityType
+ */
+export class EntityType {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of EntityType to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.displayName = _value.displayName;
+        this.kind = _value.kind;
+        this.autoExpansionMode = _value.autoExpansionMode;
+        this.entities = (_value.entities || []).map(m => new EntityType.Entity(m));
+        this.nextPageToken = _value.nextPageToken;
+        this.entityCount = _value.entityCount;
+        this.status = _value.status;
+        this.synonymCount = _value.synonymCount;
+        EntityType.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new EntityType();
+        EntityType.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+        _instance.displayName = _instance.displayName || '';
+        _instance.kind = _instance.kind || 0;
+        _instance.autoExpansionMode = _instance.autoExpansionMode || 0;
+        _instance.entities = _instance.entities || [];
+        _instance.nextPageToken = _instance.nextPageToken || '';
+        _instance.entityCount = _instance.entityCount || 0;
+        _instance.status = _instance.status || 0;
+        _instance.synonymCount = _instance.synonymCount || 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.name = _reader.readString();
+                    break;
+                case 2:
+                    _instance.displayName = _reader.readString();
+                    break;
+                case 3:
+                    _instance.kind = _reader.readEnum();
+                    break;
+                case 4:
+                    _instance.autoExpansionMode = _reader.readEnum();
+                    break;
+                case 6:
+                    const messageInitializer6 = new EntityType.Entity();
+                    _reader.readMessage(messageInitializer6, EntityType.Entity.deserializeBinaryFromReader);
+                    (_instance.entities = _instance.entities || []).push(messageInitializer6);
+                    break;
+                case 10:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                case 11:
+                    _instance.entityCount = _reader.readInt32();
+                    break;
+                case 12:
+                    _instance.status = _reader.readEnum();
+                    break;
+                case 13:
+                    _instance.synonymCount = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        EntityType.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+        if (_instance.displayName) {
+            _writer.writeString(2, _instance.displayName);
+        }
+        if (_instance.kind) {
+            _writer.writeEnum(3, _instance.kind);
+        }
+        if (_instance.autoExpansionMode) {
+            _writer.writeEnum(4, _instance.autoExpansionMode);
+        }
+        if (_instance.entities && _instance.entities.length) {
+            _writer.writeRepeatedMessage(6, _instance.entities, EntityType.Entity.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(10, _instance.nextPageToken);
+        }
+        if (_instance.entityCount) {
+            _writer.writeInt32(11, _instance.entityCount);
+        }
+        if (_instance.status) {
+            _writer.writeEnum(12, _instance.status);
+        }
+        if (_instance.synonymCount) {
+            _writer.writeInt32(13, _instance.synonymCount);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    set displayName(value) {
+        this._displayName = value;
+    }
+    get kind() {
+        return this._kind;
+    }
+    set kind(value) {
+        this._kind = value;
+    }
+    get autoExpansionMode() {
+        return this._autoExpansionMode;
+    }
+    set autoExpansionMode(value) {
+        this._autoExpansionMode = value;
+    }
+    get entities() {
+        return this._entities;
+    }
+    set entities(value) {
+        this._entities = value;
+    }
+    get nextPageToken() {
+        return this._nextPageToken;
+    }
+    set nextPageToken(value) {
+        this._nextPageToken = value;
+    }
+    get entityCount() {
+        return this._entityCount;
+    }
+    set entityCount(value) {
+        this._entityCount = value;
+    }
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+    }
+    get synonymCount() {
+        return this._synonymCount;
+    }
+    set synonymCount(value) {
+        this._synonymCount = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        EntityType.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            kind: this.kind,
+            autoExpansionMode: this.autoExpansionMode,
+            entities: (this.entities || []).map(m => m.toObject()),
+            nextPageToken: this.nextPageToken,
+            entityCount: this.entityCount,
+            status: this.status,
+            synonymCount: this.synonymCount
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            kind: EntityType.Kind[this.kind === null || this.kind === undefined ? 0 : this.kind],
+            autoExpansionMode: EntityType.AutoExpansionMode[this.autoExpansionMode === null ||
+                this.autoExpansionMode === undefined
+                ? 0
+                : this.autoExpansionMode],
+            entities: (this.entities || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken,
+            entityCount: this.entityCount,
+            status: EntityType.EntityTypeStatus[this.status === null || this.status === undefined ? 0 : this.status],
+            synonymCount: this.synonymCount
+        };
+    }
+}
+EntityType.id = 'ondewo.nlu.EntityType';
+(function (EntityType) {
+    let Kind;
+    (function (Kind) {
+        Kind[Kind["KIND_UNSPECIFIED"] = 0] = "KIND_UNSPECIFIED";
+        Kind[Kind["KIND_MAP"] = 1] = "KIND_MAP";
+        Kind[Kind["KIND_LIST"] = 2] = "KIND_LIST";
+    })(Kind = EntityType.Kind || (EntityType.Kind = {}));
+    let EntityTypeStatus;
+    (function (EntityTypeStatus) {
+        EntityTypeStatus[EntityTypeStatus["ACTIVE"] = 0] = "ACTIVE";
+        EntityTypeStatus[EntityTypeStatus["INACTIVE"] = 1] = "INACTIVE";
+    })(EntityTypeStatus = EntityType.EntityTypeStatus || (EntityType.EntityTypeStatus = {}));
+    let AutoExpansionMode;
+    (function (AutoExpansionMode) {
+        AutoExpansionMode[AutoExpansionMode["AUTO_EXPANSION_MODE_UNSPECIFIED"] = 0] = "AUTO_EXPANSION_MODE_UNSPECIFIED";
+        AutoExpansionMode[AutoExpansionMode["AUTO_EXPANSION_MODE_DEFAULT"] = 1] = "AUTO_EXPANSION_MODE_DEFAULT";
+    })(AutoExpansionMode = EntityType.AutoExpansionMode || (EntityType.AutoExpansionMode = {}));
+    /**
+     * Message implementation for ondewo.nlu.Entity
+     */
+    class Entity {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Entity to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.value = _value.value;
+            this.synonyms = (_value.synonyms || []).slice();
+            this.name = _value.name;
+            this.displayName = _value.displayName;
+            this.synonymCount = _value.synonymCount;
+            this.languageCode = _value.languageCode;
+            Entity.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new Entity();
+            Entity.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.value = _instance.value || '';
+            _instance.synonyms = _instance.synonyms || [];
+            _instance.name = _instance.name || '';
+            _instance.displayName = _instance.displayName || '';
+            _instance.synonymCount = _instance.synonymCount || 0;
+            _instance.languageCode = _instance.languageCode || '';
+        }
+        /**
+         * 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.value = _reader.readString();
+                        break;
+                    case 2:
+                        (_instance.synonyms = _instance.synonyms || []).push(_reader.readString());
+                        break;
+                    case 3:
+                        _instance.name = _reader.readString();
+                        break;
+                    case 4:
+                        _instance.displayName = _reader.readString();
+                        break;
+                    case 5:
+                        _instance.synonymCount = _reader.readInt32();
+                        break;
+                    case 6:
+                        _instance.languageCode = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            Entity.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.value) {
+                _writer.writeString(1, _instance.value);
+            }
+            if (_instance.synonyms && _instance.synonyms.length) {
+                _writer.writeRepeatedString(2, _instance.synonyms);
+            }
+            if (_instance.name) {
+                _writer.writeString(3, _instance.name);
+            }
+            if (_instance.displayName) {
+                _writer.writeString(4, _instance.displayName);
+            }
+            if (_instance.synonymCount) {
+                _writer.writeInt32(5, _instance.synonymCount);
+            }
+            if (_instance.languageCode) {
+                _writer.writeString(6, _instance.languageCode);
+            }
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        get synonyms() {
+            return this._synonyms;
+        }
+        set synonyms(value) {
+            this._synonyms = value;
+        }
+        get name() {
+            return this._name;
+        }
+        set name(value) {
+            this._name = value;
+        }
+        get displayName() {
+            return this._displayName;
+        }
+        set displayName(value) {
+            this._displayName = value;
+        }
+        get synonymCount() {
+            return this._synonymCount;
+        }
+        set synonymCount(value) {
+            this._synonymCount = value;
+        }
+        get languageCode() {
+            return this._languageCode;
+        }
+        set languageCode(value) {
+            this._languageCode = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            Entity.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                value: this.value,
+                synonyms: (this.synonyms || []).slice(),
+                name: this.name,
+                displayName: this.displayName,
+                synonymCount: this.synonymCount,
+                languageCode: this.languageCode
+            };
+        }
+        /**
+         * 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 {
+                value: this.value,
+                synonyms: (this.synonyms || []).slice(),
+                name: this.name,
+                displayName: this.displayName,
+                synonymCount: this.synonymCount,
+                languageCode: this.languageCode
+            };
+        }
+    }
+    Entity.id = 'ondewo.nlu.Entity';
+    EntityType.Entity = Entity;
+})(EntityType || (EntityType = {}));
+/**
+ * Message implementation for ondewo.nlu.ListEntityTypesRequest
+ */
+export class ListEntityTypesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListEntityTypesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.languageCode = _value.languageCode;
+        this.pageToken = _value.pageToken;
+        this.entityTypeView = _value.entityTypeView;
+        this.filterByCategory = _value.filterByCategory;
+        this.sortByField = _value.sortByField
+            ? new EntityTypeSorting(_value.sortByField)
+            : undefined;
+        ListEntityTypesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListEntityTypesRequest();
+        ListEntityTypesRequest.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.parent = _instance.parent || '';
+        _instance.languageCode = _instance.languageCode || '';
+        _instance.pageToken = _instance.pageToken || '';
+        _instance.entityTypeView = _instance.entityTypeView || 0;
+        _instance.filterByCategory = _instance.filterByCategory || 0;
+        _instance.sortByField = _instance.sortByField || 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.parent = _reader.readString();
+                    break;
+                case 2:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 4:
+                    _instance.pageToken = _reader.readString();
+                    break;
+                case 5:
+                    _instance.entityTypeView = _reader.readEnum();
+                    break;
+                case 6:
+                    _instance.filterByCategory = _reader.readEnum();
+                    break;
+                case 7:
+                    _instance.sortByField = new EntityTypeSorting();
+                    _reader.readMessage(_instance.sortByField, EntityTypeSorting.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListEntityTypesRequest.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.parent) {
+            _writer.writeString(1, _instance.parent);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.pageToken) {
+            _writer.writeString(4, _instance.pageToken);
+        }
+        if (_instance.entityTypeView) {
+            _writer.writeEnum(5, _instance.entityTypeView);
+        }
+        if (_instance.filterByCategory) {
+            _writer.writeEnum(6, _instance.filterByCategory);
+        }
+        if (_instance.sortByField) {
+            _writer.writeMessage(7, _instance.sortByField, EntityTypeSorting.serializeBinaryToWriter);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    get entityTypeView() {
+        return this._entityTypeView;
+    }
+    set entityTypeView(value) {
+        this._entityTypeView = value;
+    }
+    get filterByCategory() {
+        return this._filterByCategory;
+    }
+    set filterByCategory(value) {
+        this._filterByCategory = value;
+    }
+    get sortByField() {
+        return this._sortByField;
+    }
+    set sortByField(value) {
+        this._sortByField = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListEntityTypesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            languageCode: this.languageCode,
+            pageToken: this.pageToken,
+            entityTypeView: this.entityTypeView,
+            filterByCategory: this.filterByCategory,
+            sortByField: this.sortByField ? this.sortByField.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 {
+            parent: this.parent,
+            languageCode: this.languageCode,
+            pageToken: this.pageToken,
+            entityTypeView: EntityTypeView[this.entityTypeView === null || this.entityTypeView === undefined
+                ? 0
+                : this.entityTypeView],
+            filterByCategory: EntityTypeCategory[this.filterByCategory === null || this.filterByCategory === undefined
+                ? 0
+                : this.filterByCategory],
+            sortByField: this.sortByField
+                ? this.sortByField.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+ListEntityTypesRequest.id = 'ondewo.nlu.ListEntityTypesRequest';
+/**
+ * Message implementation for ondewo.nlu.ListEntityTypesResponse
+ */
+export class ListEntityTypesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListEntityTypesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityTypes = (_value.entityTypes || []).map(m => new EntityType(m));
+        this.nextPageToken = _value.nextPageToken;
+        ListEntityTypesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListEntityTypesResponse();
+        ListEntityTypesResponse.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.entityTypes = _instance.entityTypes || [];
+        _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 EntityType();
+                    _reader.readMessage(messageInitializer1, EntityType.deserializeBinaryFromReader);
+                    (_instance.entityTypes = _instance.entityTypes || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListEntityTypesResponse.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.entityTypes && _instance.entityTypes.length) {
+            _writer.writeRepeatedMessage(1, _instance.entityTypes, EntityType.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    get entityTypes() {
+        return this._entityTypes;
+    }
+    set entityTypes(value) {
+        this._entityTypes = 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();
+        ListEntityTypesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityTypes: (this.entityTypes || []).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 {
+            entityTypes: (this.entityTypes || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+ListEntityTypesResponse.id = 'ondewo.nlu.ListEntityTypesResponse';
+/**
+ * Message implementation for ondewo.nlu.GetEntityTypeRequest
+ */
+export class GetEntityTypeRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetEntityTypeRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.languageCode = _value.languageCode;
+        this.pageToken = _value.pageToken;
+        this.entityTypeView = _value.entityTypeView;
+        GetEntityTypeRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetEntityTypeRequest();
+        GetEntityTypeRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+        _instance.languageCode = _instance.languageCode || '';
+        _instance.pageToken = _instance.pageToken || '';
+        _instance.entityTypeView = _instance.entityTypeView || 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.name = _reader.readString();
+                    break;
+                case 2:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 5:
+                    _instance.pageToken = _reader.readString();
+                    break;
+                case 6:
+                    _instance.entityTypeView = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetEntityTypeRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.pageToken) {
+            _writer.writeString(5, _instance.pageToken);
+        }
+        if (_instance.entityTypeView) {
+            _writer.writeEnum(6, _instance.entityTypeView);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    get entityTypeView() {
+        return this._entityTypeView;
+    }
+    set entityTypeView(value) {
+        this._entityTypeView = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetEntityTypeRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            languageCode: this.languageCode,
+            pageToken: this.pageToken,
+            entityTypeView: this.entityTypeView
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name,
+            languageCode: this.languageCode,
+            pageToken: this.pageToken,
+            entityTypeView: EntityTypeView[this.entityTypeView === null || this.entityTypeView === undefined
+                ? 0
+                : this.entityTypeView]
+        };
+    }
+}
+GetEntityTypeRequest.id = 'ondewo.nlu.GetEntityTypeRequest';
+/**
+ * Message implementation for ondewo.nlu.CreateEntityTypeRequest
+ */
+export class CreateEntityTypeRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CreateEntityTypeRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.entityType = _value.entityType
+            ? new EntityType(_value.entityType)
+            : undefined;
+        this.languageCode = _value.languageCode;
+        this.entityTypeView = _value.entityTypeView;
+        CreateEntityTypeRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CreateEntityTypeRequest();
+        CreateEntityTypeRequest.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.parent = _instance.parent || '';
+        _instance.entityType = _instance.entityType || undefined;
+        _instance.languageCode = _instance.languageCode || '';
+        _instance.entityTypeView = _instance.entityTypeView || 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.parent = _reader.readString();
+                    break;
+                case 2:
+                    _instance.entityType = new EntityType();
+                    _reader.readMessage(_instance.entityType, EntityType.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 6:
+                    _instance.entityTypeView = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CreateEntityTypeRequest.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.parent) {
+            _writer.writeString(1, _instance.parent);
+        }
+        if (_instance.entityType) {
+            _writer.writeMessage(2, _instance.entityType, EntityType.serializeBinaryToWriter);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(3, _instance.languageCode);
+        }
+        if (_instance.entityTypeView) {
+            _writer.writeEnum(6, _instance.entityTypeView);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get entityType() {
+        return this._entityType;
+    }
+    set entityType(value) {
+        this._entityType = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get entityTypeView() {
+        return this._entityTypeView;
+    }
+    set entityTypeView(value) {
+        this._entityTypeView = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CreateEntityTypeRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            entityType: this.entityType ? this.entityType.toObject() : undefined,
+            languageCode: this.languageCode,
+            entityTypeView: this.entityTypeView
+        };
+    }
+    /**
+     * 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 {
+            parent: this.parent,
+            entityType: this.entityType
+                ? this.entityType.toProtobufJSON(options)
+                : null,
+            languageCode: this.languageCode,
+            entityTypeView: EntityTypeView[this.entityTypeView === null || this.entityTypeView === undefined
+                ? 0
+                : this.entityTypeView]
+        };
+    }
+}
+CreateEntityTypeRequest.id = 'ondewo.nlu.CreateEntityTypeRequest';
+/**
+ * Message implementation for ondewo.nlu.UpdateEntityTypeRequest
+ */
+export class UpdateEntityTypeRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of UpdateEntityTypeRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityType = _value.entityType
+            ? new EntityType(_value.entityType)
+            : undefined;
+        this.languageCode = _value.languageCode;
+        this.updateMask = _value.updateMask
+            ? new googleProtobuf008.FieldMask(_value.updateMask)
+            : undefined;
+        this.entityTypeView = _value.entityTypeView;
+        UpdateEntityTypeRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new UpdateEntityTypeRequest();
+        UpdateEntityTypeRequest.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.entityType = _instance.entityType || undefined;
+        _instance.languageCode = _instance.languageCode || '';
+        _instance.updateMask = _instance.updateMask || undefined;
+        _instance.entityTypeView = _instance.entityTypeView || 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.entityType = new EntityType();
+                    _reader.readMessage(_instance.entityType, EntityType.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 3:
+                    _instance.updateMask = new googleProtobuf008.FieldMask();
+                    _reader.readMessage(_instance.updateMask, googleProtobuf008.FieldMask.deserializeBinaryFromReader);
+                    break;
+                case 6:
+                    _instance.entityTypeView = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        UpdateEntityTypeRequest.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.entityType) {
+            _writer.writeMessage(1, _instance.entityType, EntityType.serializeBinaryToWriter);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.updateMask) {
+            _writer.writeMessage(3, _instance.updateMask, googleProtobuf008.FieldMask.serializeBinaryToWriter);
+        }
+        if (_instance.entityTypeView) {
+            _writer.writeEnum(6, _instance.entityTypeView);
+        }
+    }
+    get entityType() {
+        return this._entityType;
+    }
+    set entityType(value) {
+        this._entityType = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get updateMask() {
+        return this._updateMask;
+    }
+    set updateMask(value) {
+        this._updateMask = value;
+    }
+    get entityTypeView() {
+        return this._entityTypeView;
+    }
+    set entityTypeView(value) {
+        this._entityTypeView = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        UpdateEntityTypeRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityType: this.entityType ? this.entityType.toObject() : undefined,
+            languageCode: this.languageCode,
+            updateMask: this.updateMask ? this.updateMask.toObject() : undefined,
+            entityTypeView: this.entityTypeView
+        };
+    }
+    /**
+     * 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 {
+            entityType: this.entityType
+                ? this.entityType.toProtobufJSON(options)
+                : null,
+            languageCode: this.languageCode,
+            updateMask: this.updateMask
+                ? this.updateMask.toProtobufJSON(options)
+                : null,
+            entityTypeView: EntityTypeView[this.entityTypeView === null || this.entityTypeView === undefined
+                ? 0
+                : this.entityTypeView]
+        };
+    }
+}
+UpdateEntityTypeRequest.id = 'ondewo.nlu.UpdateEntityTypeRequest';
+/**
+ * Message implementation for ondewo.nlu.DeleteEntityTypeRequest
+ */
+export class DeleteEntityTypeRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DeleteEntityTypeRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        DeleteEntityTypeRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new DeleteEntityTypeRequest();
+        DeleteEntityTypeRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.name = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        DeleteEntityTypeRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        DeleteEntityTypeRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name
+        };
+    }
+}
+DeleteEntityTypeRequest.id = 'ondewo.nlu.DeleteEntityTypeRequest';
+/**
+ * Message implementation for ondewo.nlu.BatchUpdateEntityTypesRequest
+ */
+export class BatchUpdateEntityTypesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchUpdateEntityTypesRequest to deeply clone from
+     */
+    constructor(_value) {
+        this._entityTypeBatch = BatchUpdateEntityTypesRequest.EntityTypeBatchCase.none;
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.entityTypeBatchUri = _value.entityTypeBatchUri;
+        this.entityTypeBatchInline = _value.entityTypeBatchInline
+            ? new EntityTypeBatch(_value.entityTypeBatchInline)
+            : undefined;
+        this.languageCode = _value.languageCode;
+        this.updateMask = _value.updateMask
+            ? new googleProtobuf008.FieldMask(_value.updateMask)
+            : undefined;
+        BatchUpdateEntityTypesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchUpdateEntityTypesRequest();
+        BatchUpdateEntityTypesRequest.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.parent = _instance.parent || '';
+        _instance.languageCode = _instance.languageCode || '';
+        _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.parent = _reader.readString();
+                    break;
+                case 2:
+                    _instance.entityTypeBatchUri = _reader.readString();
+                    break;
+                case 3:
+                    _instance.entityTypeBatchInline = new EntityTypeBatch();
+                    _reader.readMessage(_instance.entityTypeBatchInline, EntityTypeBatch.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 5:
+                    _instance.updateMask = new googleProtobuf008.FieldMask();
+                    _reader.readMessage(_instance.updateMask, googleProtobuf008.FieldMask.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchUpdateEntityTypesRequest.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.parent) {
+            _writer.writeString(1, _instance.parent);
+        }
+        if (_instance.entityTypeBatchUri || _instance.entityTypeBatchUri === '') {
+            _writer.writeString(2, _instance.entityTypeBatchUri);
+        }
+        if (_instance.entityTypeBatchInline) {
+            _writer.writeMessage(3, _instance.entityTypeBatchInline, EntityTypeBatch.serializeBinaryToWriter);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(4, _instance.languageCode);
+        }
+        if (_instance.updateMask) {
+            _writer.writeMessage(5, _instance.updateMask, googleProtobuf008.FieldMask.serializeBinaryToWriter);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get entityTypeBatchUri() {
+        return this._entityTypeBatchUri;
+    }
+    set entityTypeBatchUri(value) {
+        if (value !== undefined && value !== null) {
+            this._entityTypeBatchInline = undefined;
+            this._entityTypeBatch =
+                BatchUpdateEntityTypesRequest.EntityTypeBatchCase.entityTypeBatchUri;
+        }
+        this._entityTypeBatchUri = value;
+    }
+    get entityTypeBatchInline() {
+        return this._entityTypeBatchInline;
+    }
+    set entityTypeBatchInline(value) {
+        if (value !== undefined && value !== null) {
+            this._entityTypeBatchUri = undefined;
+            this._entityTypeBatch =
+                BatchUpdateEntityTypesRequest.EntityTypeBatchCase.entityTypeBatchInline;
+        }
+        this._entityTypeBatchInline = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get updateMask() {
+        return this._updateMask;
+    }
+    set updateMask(value) {
+        this._updateMask = value;
+    }
+    get entityTypeBatch() {
+        return this._entityTypeBatch;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchUpdateEntityTypesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            entityTypeBatchUri: this.entityTypeBatchUri,
+            entityTypeBatchInline: this.entityTypeBatchInline
+                ? this.entityTypeBatchInline.toObject()
+                : undefined,
+            languageCode: this.languageCode,
+            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 {
+            parent: this.parent,
+            entityTypeBatchUri: this.entityTypeBatchUri === null ||
+                this.entityTypeBatchUri === undefined
+                ? null
+                : this.entityTypeBatchUri,
+            entityTypeBatchInline: this.entityTypeBatchInline
+                ? this.entityTypeBatchInline.toProtobufJSON(options)
+                : null,
+            languageCode: this.languageCode,
+            updateMask: this.updateMask
+                ? this.updateMask.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+BatchUpdateEntityTypesRequest.id = 'ondewo.nlu.BatchUpdateEntityTypesRequest';
+(function (BatchUpdateEntityTypesRequest) {
+    let EntityTypeBatchCase;
+    (function (EntityTypeBatchCase) {
+        EntityTypeBatchCase[EntityTypeBatchCase["none"] = 0] = "none";
+        EntityTypeBatchCase[EntityTypeBatchCase["entityTypeBatchUri"] = 1] = "entityTypeBatchUri";
+        EntityTypeBatchCase[EntityTypeBatchCase["entityTypeBatchInline"] = 2] = "entityTypeBatchInline";
+    })(EntityTypeBatchCase = BatchUpdateEntityTypesRequest.EntityTypeBatchCase || (BatchUpdateEntityTypesRequest.EntityTypeBatchCase = {}));
+})(BatchUpdateEntityTypesRequest || (BatchUpdateEntityTypesRequest = {}));
+/**
+ * Message implementation for ondewo.nlu.BatchUpdateEntityTypesResponse
+ */
+export class BatchUpdateEntityTypesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchUpdateEntityTypesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityTypes = (_value.entityTypes || []).map(m => new EntityType(m));
+        BatchUpdateEntityTypesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchUpdateEntityTypesResponse();
+        BatchUpdateEntityTypesResponse.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.entityTypes = _instance.entityTypes || [];
+    }
+    /**
+     * 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 EntityType();
+                    _reader.readMessage(messageInitializer1, EntityType.deserializeBinaryFromReader);
+                    (_instance.entityTypes = _instance.entityTypes || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchUpdateEntityTypesResponse.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.entityTypes && _instance.entityTypes.length) {
+            _writer.writeRepeatedMessage(1, _instance.entityTypes, EntityType.serializeBinaryToWriter);
+        }
+    }
+    get entityTypes() {
+        return this._entityTypes;
+    }
+    set entityTypes(value) {
+        this._entityTypes = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchUpdateEntityTypesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityTypes: (this.entityTypes || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            entityTypes: (this.entityTypes || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+BatchUpdateEntityTypesResponse.id = 'ondewo.nlu.BatchUpdateEntityTypesResponse';
+/**
+ * Message implementation for ondewo.nlu.BatchDeleteEntityTypesRequest
+ */
+export class BatchDeleteEntityTypesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchDeleteEntityTypesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.entityTypeNames = (_value.entityTypeNames || []).slice();
+        BatchDeleteEntityTypesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchDeleteEntityTypesRequest();
+        BatchDeleteEntityTypesRequest.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.parent = _instance.parent || '';
+        _instance.entityTypeNames = _instance.entityTypeNames || [];
+    }
+    /**
+     * 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.parent = _reader.readString();
+                    break;
+                case 2:
+                    (_instance.entityTypeNames = _instance.entityTypeNames || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchDeleteEntityTypesRequest.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.parent) {
+            _writer.writeString(1, _instance.parent);
+        }
+        if (_instance.entityTypeNames && _instance.entityTypeNames.length) {
+            _writer.writeRepeatedString(2, _instance.entityTypeNames);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get entityTypeNames() {
+        return this._entityTypeNames;
+    }
+    set entityTypeNames(value) {
+        this._entityTypeNames = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchDeleteEntityTypesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            entityTypeNames: (this.entityTypeNames || []).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 {
+            parent: this.parent,
+            entityTypeNames: (this.entityTypeNames || []).slice()
+        };
+    }
+}
+BatchDeleteEntityTypesRequest.id = 'ondewo.nlu.BatchDeleteEntityTypesRequest';
+/**
+ * Message implementation for ondewo.nlu.EntityTypeBatch
+ */
+export class EntityTypeBatch {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of EntityTypeBatch to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityTypes = (_value.entityTypes || []).map(m => new EntityType(m));
+        EntityTypeBatch.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new EntityTypeBatch();
+        EntityTypeBatch.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.entityTypes = _instance.entityTypes || [];
+    }
+    /**
+     * 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 EntityType();
+                    _reader.readMessage(messageInitializer1, EntityType.deserializeBinaryFromReader);
+                    (_instance.entityTypes = _instance.entityTypes || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        EntityTypeBatch.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.entityTypes && _instance.entityTypes.length) {
+            _writer.writeRepeatedMessage(1, _instance.entityTypes, EntityType.serializeBinaryToWriter);
+        }
+    }
+    get entityTypes() {
+        return this._entityTypes;
+    }
+    set entityTypes(value) {
+        this._entityTypes = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        EntityTypeBatch.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityTypes: (this.entityTypes || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            entityTypes: (this.entityTypes || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+EntityTypeBatch.id = 'ondewo.nlu.EntityTypeBatch';
+/**
+ * Message implementation for ondewo.nlu.EntityTypeSorting
+ */
+export class EntityTypeSorting {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of EntityTypeSorting to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.sortingField = _value.sortingField;
+        this.sortingMode = _value.sortingMode;
+        EntityTypeSorting.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new EntityTypeSorting();
+        EntityTypeSorting.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.sortingField = _instance.sortingField || 0;
+        _instance.sortingMode = _instance.sortingMode || 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.sortingField = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.sortingMode = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        EntityTypeSorting.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.sortingField) {
+            _writer.writeEnum(1, _instance.sortingField);
+        }
+        if (_instance.sortingMode) {
+            _writer.writeEnum(2, _instance.sortingMode);
+        }
+    }
+    get sortingField() {
+        return this._sortingField;
+    }
+    set sortingField(value) {
+        this._sortingField = value;
+    }
+    get sortingMode() {
+        return this._sortingMode;
+    }
+    set sortingMode(value) {
+        this._sortingMode = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        EntityTypeSorting.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            sortingField: this.sortingField,
+            sortingMode: this.sortingMode
+        };
+    }
+    /**
+     * 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 {
+            sortingField: EntityTypeSorting.EntityTypeSortingField[this.sortingField === null || this.sortingField === undefined
+                ? 0
+                : this.sortingField],
+            sortingMode: ondewoNlu009.SortingMode[this.sortingMode === null || this.sortingMode === undefined
+                ? 0
+                : this.sortingMode]
+        };
+    }
+}
+EntityTypeSorting.id = 'ondewo.nlu.EntityTypeSorting';
+(function (EntityTypeSorting) {
+    let EntityTypeSortingField;
+    (function (EntityTypeSortingField) {
+        EntityTypeSortingField[EntityTypeSortingField["NO_ENTITY_TYPE_SORTING"] = 0] = "NO_ENTITY_TYPE_SORTING";
+        EntityTypeSortingField[EntityTypeSortingField["SORT_ENTITY_TYPE_BY_NAME"] = 1] = "SORT_ENTITY_TYPE_BY_NAME";
+        EntityTypeSortingField[EntityTypeSortingField["SORT_ENTITY_TYPE_BY_CREATION_DATE"] = 2] = "SORT_ENTITY_TYPE_BY_CREATION_DATE";
+        EntityTypeSortingField[EntityTypeSortingField["SORT_ENTITY_TYPE_BY_LAST_UPDATED"] = 3] = "SORT_ENTITY_TYPE_BY_LAST_UPDATED";
+        EntityTypeSortingField[EntityTypeSortingField["SORT_ENTITY_TYPE_BY_ENTITY_VALUE_COUNT"] = 4] = "SORT_ENTITY_TYPE_BY_ENTITY_VALUE_COUNT";
+        EntityTypeSortingField[EntityTypeSortingField["SORT_ENTITY_TYPE_BY_SYNONYM_COUNT"] = 5] = "SORT_ENTITY_TYPE_BY_SYNONYM_COUNT";
+    })(EntityTypeSortingField = EntityTypeSorting.EntityTypeSortingField || (EntityTypeSorting.EntityTypeSortingField = {}));
+})(EntityTypeSorting || (EntityTypeSorting = {}));
+/**
+ * Message implementation for ondewo.nlu.BatchEntitiesResponse
+ */
+export class BatchEntitiesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchEntitiesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityStatuses = (_value.entityStatuses || []).map(m => new BatchEntitiesResponse.EntityStatus(m));
+        this.hasErrors = _value.hasErrors;
+        BatchEntitiesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchEntitiesResponse();
+        BatchEntitiesResponse.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.entityStatuses = _instance.entityStatuses || [];
+        _instance.hasErrors = _instance.hasErrors || false;
+    }
+    /**
+     * 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 BatchEntitiesResponse.EntityStatus();
+                    _reader.readMessage(messageInitializer1, BatchEntitiesResponse.EntityStatus.deserializeBinaryFromReader);
+                    (_instance.entityStatuses = _instance.entityStatuses || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.hasErrors = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchEntitiesResponse.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.entityStatuses && _instance.entityStatuses.length) {
+            _writer.writeRepeatedMessage(1, _instance.entityStatuses, BatchEntitiesResponse.EntityStatus.serializeBinaryToWriter);
+        }
+        if (_instance.hasErrors) {
+            _writer.writeBool(2, _instance.hasErrors);
+        }
+    }
+    get entityStatuses() {
+        return this._entityStatuses;
+    }
+    set entityStatuses(value) {
+        this._entityStatuses = value;
+    }
+    get hasErrors() {
+        return this._hasErrors;
+    }
+    set hasErrors(value) {
+        this._hasErrors = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchEntitiesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityStatuses: (this.entityStatuses || []).map(m => m.toObject()),
+            hasErrors: this.hasErrors
+        };
+    }
+    /**
+     * 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 {
+            entityStatuses: (this.entityStatuses || []).map(m => m.toProtobufJSON(options)),
+            hasErrors: this.hasErrors
+        };
+    }
+}
+BatchEntitiesResponse.id = 'ondewo.nlu.BatchEntitiesResponse';
+(function (BatchEntitiesResponse) {
+    /**
+     * Message implementation for ondewo.nlu.EntityStatus
+     */
+    class EntityStatus {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of EntityStatus to deeply clone from
+         */
+        constructor(_value) {
+            this._entityOrStatus = EntityStatus.EntityOrStatusCase.none;
+            _value = _value || {};
+            this.entity = _value.entity
+                ? new EntityType.Entity(_value.entity)
+                : undefined;
+            this.errorMessage = _value.errorMessage;
+            EntityStatus.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new EntityStatus();
+            EntityStatus.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.entity = new EntityType.Entity();
+                        _reader.readMessage(_instance.entity, EntityType.Entity.deserializeBinaryFromReader);
+                        break;
+                    case 2:
+                        _instance.errorMessage = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            EntityStatus.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.entity) {
+                _writer.writeMessage(1, _instance.entity, EntityType.Entity.serializeBinaryToWriter);
+            }
+            if (_instance.errorMessage || _instance.errorMessage === '') {
+                _writer.writeString(2, _instance.errorMessage);
+            }
+        }
+        get entity() {
+            return this._entity;
+        }
+        set entity(value) {
+            if (value !== undefined && value !== null) {
+                this._errorMessage = undefined;
+                this._entityOrStatus = EntityStatus.EntityOrStatusCase.entity;
+            }
+            this._entity = value;
+        }
+        get errorMessage() {
+            return this._errorMessage;
+        }
+        set errorMessage(value) {
+            if (value !== undefined && value !== null) {
+                this._entity = undefined;
+                this._entityOrStatus = EntityStatus.EntityOrStatusCase.errorMessage;
+            }
+            this._errorMessage = value;
+        }
+        get entityOrStatus() {
+            return this._entityOrStatus;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            EntityStatus.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                entity: this.entity ? this.entity.toObject() : undefined,
+                errorMessage: this.errorMessage
+            };
+        }
+        /**
+         * 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 {
+                entity: this.entity ? this.entity.toProtobufJSON(options) : null,
+                errorMessage: this.errorMessage === null || this.errorMessage === undefined
+                    ? null
+                    : this.errorMessage
+            };
+        }
+    }
+    EntityStatus.id = 'ondewo.nlu.EntityStatus';
+    BatchEntitiesResponse.EntityStatus = EntityStatus;
+    (function (EntityStatus) {
+        let EntityOrStatusCase;
+        (function (EntityOrStatusCase) {
+            EntityOrStatusCase[EntityOrStatusCase["none"] = 0] = "none";
+            EntityOrStatusCase[EntityOrStatusCase["entity"] = 1] = "entity";
+            EntityOrStatusCase[EntityOrStatusCase["errorMessage"] = 2] = "errorMessage";
+        })(EntityOrStatusCase = EntityStatus.EntityOrStatusCase || (EntityStatus.EntityOrStatusCase = {}));
+    })(EntityStatus = BatchEntitiesResponse.EntityStatus || (BatchEntitiesResponse.EntityStatus = {}));
+})(BatchEntitiesResponse || (BatchEntitiesResponse = {}));
+/**
+ * Message implementation for ondewo.nlu.BatchCreateEntitiesRequest
+ */
+export class BatchCreateEntitiesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchCreateEntitiesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.createEntityRequests = (_value.createEntityRequests || []).map(m => new BatchCreateEntitiesRequest.CreateEntityRequest(m));
+        BatchCreateEntitiesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchCreateEntitiesRequest();
+        BatchCreateEntitiesRequest.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.createEntityRequests = _instance.createEntityRequests || [];
+    }
+    /**
+     * 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 BatchCreateEntitiesRequest.CreateEntityRequest();
+                    _reader.readMessage(messageInitializer1, BatchCreateEntitiesRequest.CreateEntityRequest
+                        .deserializeBinaryFromReader);
+                    (_instance.createEntityRequests =
+                        _instance.createEntityRequests || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchCreateEntitiesRequest.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.createEntityRequests &&
+            _instance.createEntityRequests.length) {
+            _writer.writeRepeatedMessage(1, _instance.createEntityRequests, BatchCreateEntitiesRequest.CreateEntityRequest.serializeBinaryToWriter);
+        }
+    }
+    get createEntityRequests() {
+        return this._createEntityRequests;
+    }
+    set createEntityRequests(value) {
+        this._createEntityRequests = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchCreateEntitiesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            createEntityRequests: (this.createEntityRequests || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            createEntityRequests: (this.createEntityRequests || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+BatchCreateEntitiesRequest.id = 'ondewo.nlu.BatchCreateEntitiesRequest';
+(function (BatchCreateEntitiesRequest) {
+    /**
+     * Message implementation for ondewo.nlu.CreateEntityRequest
+     */
+    class CreateEntityRequest {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of CreateEntityRequest to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.entityTypeName = _value.entityTypeName;
+            this.entity = _value.entity
+                ? new EntityType.Entity(_value.entity)
+                : undefined;
+            CreateEntityRequest.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new CreateEntityRequest();
+            CreateEntityRequest.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.entityTypeName = _instance.entityTypeName || '';
+            _instance.entity = _instance.entity || 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.entityTypeName = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.entity = new EntityType.Entity();
+                        _reader.readMessage(_instance.entity, EntityType.Entity.deserializeBinaryFromReader);
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            CreateEntityRequest.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.entityTypeName) {
+                _writer.writeString(1, _instance.entityTypeName);
+            }
+            if (_instance.entity) {
+                _writer.writeMessage(2, _instance.entity, EntityType.Entity.serializeBinaryToWriter);
+            }
+        }
+        get entityTypeName() {
+            return this._entityTypeName;
+        }
+        set entityTypeName(value) {
+            this._entityTypeName = value;
+        }
+        get entity() {
+            return this._entity;
+        }
+        set entity(value) {
+            this._entity = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            CreateEntityRequest.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                entityTypeName: this.entityTypeName,
+                entity: this.entity ? this.entity.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 {
+                entityTypeName: this.entityTypeName,
+                entity: this.entity ? this.entity.toProtobufJSON(options) : null
+            };
+        }
+    }
+    CreateEntityRequest.id = 'ondewo.nlu.CreateEntityRequest';
+    BatchCreateEntitiesRequest.CreateEntityRequest = CreateEntityRequest;
+})(BatchCreateEntitiesRequest || (BatchCreateEntitiesRequest = {}));
+/**
+ * Message implementation for ondewo.nlu.BatchUpdateEntitiesRequest
+ */
+export class BatchUpdateEntitiesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchUpdateEntitiesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entities = (_value.entities || []).map(m => new EntityType.Entity(m));
+        BatchUpdateEntitiesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchUpdateEntitiesRequest();
+        BatchUpdateEntitiesRequest.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.entities = _instance.entities || [];
+    }
+    /**
+     * 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 EntityType.Entity();
+                    _reader.readMessage(messageInitializer1, EntityType.Entity.deserializeBinaryFromReader);
+                    (_instance.entities = _instance.entities || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchUpdateEntitiesRequest.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.entities && _instance.entities.length) {
+            _writer.writeRepeatedMessage(1, _instance.entities, EntityType.Entity.serializeBinaryToWriter);
+        }
+    }
+    get entities() {
+        return this._entities;
+    }
+    set entities(value) {
+        this._entities = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchUpdateEntitiesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entities: (this.entities || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            entities: (this.entities || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+BatchUpdateEntitiesRequest.id = 'ondewo.nlu.BatchUpdateEntitiesRequest';
+/**
+ * Message implementation for ondewo.nlu.BatchGetEntitiesRequest
+ */
+export class BatchGetEntitiesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchGetEntitiesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.names = (_value.names || []).slice();
+        BatchGetEntitiesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchGetEntitiesRequest();
+        BatchGetEntitiesRequest.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.names = _instance.names || [];
+    }
+    /**
+     * 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.names = _instance.names || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchGetEntitiesRequest.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.names && _instance.names.length) {
+            _writer.writeRepeatedString(1, _instance.names);
+        }
+    }
+    get names() {
+        return this._names;
+    }
+    set names(value) {
+        this._names = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchGetEntitiesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            names: (this.names || []).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 {
+            names: (this.names || []).slice()
+        };
+    }
+}
+BatchGetEntitiesRequest.id = 'ondewo.nlu.BatchGetEntitiesRequest';
+/**
+ * Message implementation for ondewo.nlu.BatchDeleteEntitiesRequest
+ */
+export class BatchDeleteEntitiesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchDeleteEntitiesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.names = (_value.names || []).slice();
+        BatchDeleteEntitiesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchDeleteEntitiesRequest();
+        BatchDeleteEntitiesRequest.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.names = _instance.names || [];
+    }
+    /**
+     * 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.names = _instance.names || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchDeleteEntitiesRequest.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.names && _instance.names.length) {
+            _writer.writeRepeatedString(1, _instance.names);
+        }
+    }
+    get names() {
+        return this._names;
+    }
+    set names(value) {
+        this._names = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchDeleteEntitiesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            names: (this.names || []).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 {
+            names: (this.names || []).slice()
+        };
+    }
+}
+BatchDeleteEntitiesRequest.id = 'ondewo.nlu.BatchDeleteEntitiesRequest';
+/**
+ * Message implementation for ondewo.nlu.BatchDeleteEntitiesResponse
+ */
+export class BatchDeleteEntitiesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of BatchDeleteEntitiesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.deleteStatuses = (_value.deleteStatuses || []).map(m => new BatchDeleteEntitiesResponse.DeleteEntityStatus(m));
+        this.hasErrors = _value.hasErrors;
+        BatchDeleteEntitiesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new BatchDeleteEntitiesResponse();
+        BatchDeleteEntitiesResponse.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.deleteStatuses = _instance.deleteStatuses || [];
+        _instance.hasErrors = _instance.hasErrors || false;
+    }
+    /**
+     * 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 BatchDeleteEntitiesResponse.DeleteEntityStatus();
+                    _reader.readMessage(messageInitializer1, BatchDeleteEntitiesResponse.DeleteEntityStatus
+                        .deserializeBinaryFromReader);
+                    (_instance.deleteStatuses = _instance.deleteStatuses || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.hasErrors = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        BatchDeleteEntitiesResponse.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.deleteStatuses && _instance.deleteStatuses.length) {
+            _writer.writeRepeatedMessage(1, _instance.deleteStatuses, BatchDeleteEntitiesResponse.DeleteEntityStatus.serializeBinaryToWriter);
+        }
+        if (_instance.hasErrors) {
+            _writer.writeBool(2, _instance.hasErrors);
+        }
+    }
+    get deleteStatuses() {
+        return this._deleteStatuses;
+    }
+    set deleteStatuses(value) {
+        this._deleteStatuses = value;
+    }
+    get hasErrors() {
+        return this._hasErrors;
+    }
+    set hasErrors(value) {
+        this._hasErrors = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        BatchDeleteEntitiesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            deleteStatuses: (this.deleteStatuses || []).map(m => m.toObject()),
+            hasErrors: this.hasErrors
+        };
+    }
+    /**
+     * 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 {
+            deleteStatuses: (this.deleteStatuses || []).map(m => m.toProtobufJSON(options)),
+            hasErrors: this.hasErrors
+        };
+    }
+}
+BatchDeleteEntitiesResponse.id = 'ondewo.nlu.BatchDeleteEntitiesResponse';
+(function (BatchDeleteEntitiesResponse) {
+    /**
+     * Message implementation for ondewo.nlu.DeleteEntityStatus
+     */
+    class DeleteEntityStatus {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of DeleteEntityStatus to deeply clone from
+         */
+        constructor(_value) {
+            this._deleteStatus = DeleteEntityStatus.DeleteStatusCase.none;
+            _value = _value || {};
+            this.successfullyDeleted = _value.successfullyDeleted
+                ? new googleProtobuf004.Empty(_value.successfullyDeleted)
+                : undefined;
+            this.errorMessage = _value.errorMessage;
+            DeleteEntityStatus.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new DeleteEntityStatus();
+            DeleteEntityStatus.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.successfullyDeleted = new googleProtobuf004.Empty();
+                        _reader.readMessage(_instance.successfullyDeleted, googleProtobuf004.Empty.deserializeBinaryFromReader);
+                        break;
+                    case 2:
+                        _instance.errorMessage = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            DeleteEntityStatus.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.successfullyDeleted) {
+                _writer.writeMessage(1, _instance.successfullyDeleted, googleProtobuf004.Empty.serializeBinaryToWriter);
+            }
+            if (_instance.errorMessage || _instance.errorMessage === '') {
+                _writer.writeString(2, _instance.errorMessage);
+            }
+        }
+        get successfullyDeleted() {
+            return this._successfullyDeleted;
+        }
+        set successfullyDeleted(value) {
+            if (value !== undefined && value !== null) {
+                this._errorMessage = undefined;
+                this._deleteStatus =
+                    DeleteEntityStatus.DeleteStatusCase.successfullyDeleted;
+            }
+            this._successfullyDeleted = value;
+        }
+        get errorMessage() {
+            return this._errorMessage;
+        }
+        set errorMessage(value) {
+            if (value !== undefined && value !== null) {
+                this._successfullyDeleted = undefined;
+                this._deleteStatus = DeleteEntityStatus.DeleteStatusCase.errorMessage;
+            }
+            this._errorMessage = value;
+        }
+        get deleteStatus() {
+            return this._deleteStatus;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            DeleteEntityStatus.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                successfullyDeleted: this.successfullyDeleted
+                    ? this.successfullyDeleted.toObject()
+                    : undefined,
+                errorMessage: this.errorMessage
+            };
+        }
+        /**
+         * 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 {
+                successfullyDeleted: this.successfullyDeleted
+                    ? this.successfullyDeleted.toProtobufJSON(options)
+                    : null,
+                errorMessage: this.errorMessage === null || this.errorMessage === undefined
+                    ? null
+                    : this.errorMessage
+            };
+        }
+    }
+    DeleteEntityStatus.id = 'ondewo.nlu.DeleteEntityStatus';
+    BatchDeleteEntitiesResponse.DeleteEntityStatus = DeleteEntityStatus;
+    (function (DeleteEntityStatus) {
+        let DeleteStatusCase;
+        (function (DeleteStatusCase) {
+            DeleteStatusCase[DeleteStatusCase["none"] = 0] = "none";
+            DeleteStatusCase[DeleteStatusCase["successfullyDeleted"] = 1] = "successfullyDeleted";
+            DeleteStatusCase[DeleteStatusCase["errorMessage"] = 2] = "errorMessage";
+        })(DeleteStatusCase = DeleteEntityStatus.DeleteStatusCase || (DeleteEntityStatus.DeleteStatusCase = {}));
+    })(DeleteEntityStatus = BatchDeleteEntitiesResponse.DeleteEntityStatus || (BatchDeleteEntitiesResponse.DeleteEntityStatus = {}));
+})(BatchDeleteEntitiesResponse || (BatchDeleteEntitiesResponse = {}));
+/**
+ * Message implementation for ondewo.nlu.ListEntitiesRequest
+ */
+export class ListEntitiesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListEntitiesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityTypeName = _value.entityTypeName;
+        this.languageCode = _value.languageCode;
+        this.pageToken = _value.pageToken;
+        this.sortByField = _value.sortByField
+            ? new EntityValueSorting(_value.sortByField)
+            : undefined;
+        this.searchByPattern = _value.searchByPattern;
+        ListEntitiesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListEntitiesRequest();
+        ListEntitiesRequest.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.entityTypeName = _instance.entityTypeName || '';
+        _instance.languageCode = _instance.languageCode || '';
+        _instance.pageToken = _instance.pageToken || '';
+        _instance.sortByField = _instance.sortByField || undefined;
+        _instance.searchByPattern = _instance.searchByPattern || '';
+    }
+    /**
+     * 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.entityTypeName = _reader.readString();
+                    break;
+                case 2:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 3:
+                    _instance.pageToken = _reader.readString();
+                    break;
+                case 5:
+                    _instance.sortByField = new EntityValueSorting();
+                    _reader.readMessage(_instance.sortByField, EntityValueSorting.deserializeBinaryFromReader);
+                    break;
+                case 6:
+                    _instance.searchByPattern = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListEntitiesRequest.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.entityTypeName) {
+            _writer.writeString(1, _instance.entityTypeName);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.pageToken) {
+            _writer.writeString(3, _instance.pageToken);
+        }
+        if (_instance.sortByField) {
+            _writer.writeMessage(5, _instance.sortByField, EntityValueSorting.serializeBinaryToWriter);
+        }
+        if (_instance.searchByPattern) {
+            _writer.writeString(6, _instance.searchByPattern);
+        }
+    }
+    get entityTypeName() {
+        return this._entityTypeName;
+    }
+    set entityTypeName(value) {
+        this._entityTypeName = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    get sortByField() {
+        return this._sortByField;
+    }
+    set sortByField(value) {
+        this._sortByField = value;
+    }
+    get searchByPattern() {
+        return this._searchByPattern;
+    }
+    set searchByPattern(value) {
+        this._searchByPattern = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListEntitiesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityTypeName: this.entityTypeName,
+            languageCode: this.languageCode,
+            pageToken: this.pageToken,
+            sortByField: this.sortByField ? this.sortByField.toObject() : undefined,
+            searchByPattern: this.searchByPattern
+        };
+    }
+    /**
+     * 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 {
+            entityTypeName: this.entityTypeName,
+            languageCode: this.languageCode,
+            pageToken: this.pageToken,
+            sortByField: this.sortByField
+                ? this.sortByField.toProtobufJSON(options)
+                : null,
+            searchByPattern: this.searchByPattern
+        };
+    }
+}
+ListEntitiesRequest.id = 'ondewo.nlu.ListEntitiesRequest';
+/**
+ * Message implementation for ondewo.nlu.ListEntitiesResponse
+ */
+export class ListEntitiesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListEntitiesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entities = (_value.entities || []).map(m => new EntityType.Entity(m));
+        this.nextPageToken = _value.nextPageToken;
+        ListEntitiesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListEntitiesResponse();
+        ListEntitiesResponse.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.entities = _instance.entities || [];
+        _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 EntityType.Entity();
+                    _reader.readMessage(messageInitializer1, EntityType.Entity.deserializeBinaryFromReader);
+                    (_instance.entities = _instance.entities || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListEntitiesResponse.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.entities && _instance.entities.length) {
+            _writer.writeRepeatedMessage(1, _instance.entities, EntityType.Entity.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    get entities() {
+        return this._entities;
+    }
+    set entities(value) {
+        this._entities = 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();
+        ListEntitiesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entities: (this.entities || []).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 {
+            entities: (this.entities || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+ListEntitiesResponse.id = 'ondewo.nlu.ListEntitiesResponse';
+/**
+ * Message implementation for ondewo.nlu.EntityValueSorting
+ */
+export class EntityValueSorting {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of EntityValueSorting to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.sortingField = _value.sortingField;
+        this.sortingMode = _value.sortingMode;
+        EntityValueSorting.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new EntityValueSorting();
+        EntityValueSorting.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.sortingField = _instance.sortingField || 0;
+        _instance.sortingMode = _instance.sortingMode || 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 7:
+                    _instance.sortingField = _reader.readEnum();
+                    break;
+                case 8:
+                    _instance.sortingMode = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        EntityValueSorting.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.sortingField) {
+            _writer.writeEnum(7, _instance.sortingField);
+        }
+        if (_instance.sortingMode) {
+            _writer.writeEnum(8, _instance.sortingMode);
+        }
+    }
+    get sortingField() {
+        return this._sortingField;
+    }
+    set sortingField(value) {
+        this._sortingField = value;
+    }
+    get sortingMode() {
+        return this._sortingMode;
+    }
+    set sortingMode(value) {
+        this._sortingMode = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        EntityValueSorting.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            sortingField: this.sortingField,
+            sortingMode: this.sortingMode
+        };
+    }
+    /**
+     * 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 {
+            sortingField: EntityValueSorting.EntityValueSortingField[this.sortingField === null || this.sortingField === undefined
+                ? 0
+                : this.sortingField],
+            sortingMode: ondewoNlu009.SortingMode[this.sortingMode === null || this.sortingMode === undefined
+                ? 0
+                : this.sortingMode]
+        };
+    }
+}
+EntityValueSorting.id = 'ondewo.nlu.EntityValueSorting';
+(function (EntityValueSorting) {
+    let EntityValueSortingField;
+    (function (EntityValueSortingField) {
+        EntityValueSortingField[EntityValueSortingField["NO_ENTITY_VALUE_SORTING"] = 0] = "NO_ENTITY_VALUE_SORTING";
+        EntityValueSortingField[EntityValueSortingField["SORT_ENTITY_VALUE_BY_DISPLAY_NAME"] = 1] = "SORT_ENTITY_VALUE_BY_DISPLAY_NAME";
+        EntityValueSortingField[EntityValueSortingField["SORT_ENTITY_VALUE_BY_VALUE"] = 2] = "SORT_ENTITY_VALUE_BY_VALUE";
+        EntityValueSortingField[EntityValueSortingField["SORT_ENTITY_VALUE_BY_SYNONYM_COUNT"] = 3] = "SORT_ENTITY_VALUE_BY_SYNONYM_COUNT";
+    })(EntityValueSortingField = EntityValueSorting.EntityValueSortingField || (EntityValueSorting.EntityValueSortingField = {}));
+})(EntityValueSorting || (EntityValueSorting = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-type.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/entity-type.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 googleRpc005 from '../../google/rpc/status.pb';\nimport * as googleProtobuf006 from '@ngx-grpc/well-known-types';\nimport * as ondewoNlu007 from '../../ondewo/nlu/operation-metadata.pb';\nimport * as googleProtobuf008 from '@ngx-grpc/well-known-types';\nimport * as ondewoNlu009 from '../../ondewo/nlu/common.pb';\nimport * as ondewoNlu010 from '../../ondewo/nlu/operations.pb';\nexport enum EntityTypeView {\n  ENTITY_TYPE_VIEW_UNSPECIFIED = 0,\n  ENTITY_TYPE_VIEW_FULL = 1,\n  ENTITY_TYPE_VIEW_PARTIAL = 2,\n  ENTITY_TYPE_VIEW_SHALLOW = 3\n}\nexport enum EntityTypeCategory {\n  ALL_ENTITY_TYPES = 0,\n  DEFAULT_ENTITY_TYPES = 1,\n  USER_DEFINED_ENTITY_TYPES = 2\n}\n/**\n * Message implementation for ondewo.nlu.EntityType\n */\nexport class EntityType implements GrpcMessage {\n  static id = 'ondewo.nlu.EntityType';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new EntityType();\n    EntityType.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: EntityType) {\n    _instance.name = _instance.name || '';\n    _instance.displayName = _instance.displayName || '';\n    _instance.kind = _instance.kind || 0;\n    _instance.autoExpansionMode = _instance.autoExpansionMode || 0;\n    _instance.entities = _instance.entities || [];\n    _instance.nextPageToken = _instance.nextPageToken || '';\n    _instance.entityCount = _instance.entityCount || 0;\n    _instance.status = _instance.status || 0;\n    _instance.synonymCount = _instance.synonymCount || 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: EntityType,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        case 2:\n          _instance.displayName = _reader.readString();\n          break;\n        case 3:\n          _instance.kind = _reader.readEnum();\n          break;\n        case 4:\n          _instance.autoExpansionMode = _reader.readEnum();\n          break;\n        case 6:\n          const messageInitializer6 = new EntityType.Entity();\n          _reader.readMessage(\n            messageInitializer6,\n            EntityType.Entity.deserializeBinaryFromReader\n          );\n          (_instance.entities = _instance.entities || []).push(\n            messageInitializer6\n          );\n          break;\n        case 10:\n          _instance.nextPageToken = _reader.readString();\n          break;\n        case 11:\n          _instance.entityCount = _reader.readInt32();\n          break;\n        case 12:\n          _instance.status = _reader.readEnum();\n          break;\n        case 13:\n          _instance.synonymCount = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    EntityType.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: EntityType, _writer: BinaryWriter) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.displayName) {\n      _writer.writeString(2, _instance.displayName);\n    }\n    if (_instance.kind) {\n      _writer.writeEnum(3, _instance.kind);\n    }\n    if (_instance.autoExpansionMode) {\n      _writer.writeEnum(4, _instance.autoExpansionMode);\n    }\n    if (_instance.entities && _instance.entities.length) {\n      _writer.writeRepeatedMessage(\n        6,\n        _instance.entities as any,\n        EntityType.Entity.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(10, _instance.nextPageToken);\n    }\n    if (_instance.entityCount) {\n      _writer.writeInt32(11, _instance.entityCount);\n    }\n    if (_instance.status) {\n      _writer.writeEnum(12, _instance.status);\n    }\n    if (_instance.synonymCount) {\n      _writer.writeInt32(13, _instance.synonymCount);\n    }\n  }\n\n  private _name?: string;\n  private _displayName?: string;\n  private _kind?: EntityType.Kind;\n  private _autoExpansionMode?: EntityType.AutoExpansionMode;\n  private _entities?: EntityType.Entity[];\n  private _nextPageToken?: string;\n  private _entityCount?: number;\n  private _status?: EntityType.EntityTypeStatus;\n  private _synonymCount?: 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 EntityType to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<EntityType.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.displayName = _value.displayName;\n    this.kind = _value.kind;\n    this.autoExpansionMode = _value.autoExpansionMode;\n    this.entities = (_value.entities || []).map(m => new EntityType.Entity(m));\n    this.nextPageToken = _value.nextPageToken;\n    this.entityCount = _value.entityCount;\n    this.status = _value.status;\n    this.synonymCount = _value.synonymCount;\n    EntityType.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = 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 kind(): EntityType.Kind | undefined {\n    return this._kind;\n  }\n  set kind(value: EntityType.Kind | undefined) {\n    this._kind = value;\n  }\n  get autoExpansionMode(): EntityType.AutoExpansionMode | undefined {\n    return this._autoExpansionMode;\n  }\n  set autoExpansionMode(value: EntityType.AutoExpansionMode | undefined) {\n    this._autoExpansionMode = value;\n  }\n  get entities(): EntityType.Entity[] | undefined {\n    return this._entities;\n  }\n  set entities(value: EntityType.Entity[] | undefined) {\n    this._entities = value;\n  }\n  get nextPageToken(): string | undefined {\n    return this._nextPageToken;\n  }\n  set nextPageToken(value: string | undefined) {\n    this._nextPageToken = value;\n  }\n  get entityCount(): number | undefined {\n    return this._entityCount;\n  }\n  set entityCount(value: number | undefined) {\n    this._entityCount = value;\n  }\n  get status(): EntityType.EntityTypeStatus | undefined {\n    return this._status;\n  }\n  set status(value: EntityType.EntityTypeStatus | undefined) {\n    this._status = value;\n  }\n  get synonymCount(): number | undefined {\n    return this._synonymCount;\n  }\n  set synonymCount(value: number | undefined) {\n    this._synonymCount = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    EntityType.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(): EntityType.AsObject {\n    return {\n      name: this.name,\n      displayName: this.displayName,\n      kind: this.kind,\n      autoExpansionMode: this.autoExpansionMode,\n      entities: (this.entities || []).map(m => m.toObject()),\n      nextPageToken: this.nextPageToken,\n      entityCount: this.entityCount,\n      status: this.status,\n      synonymCount: this.synonymCount\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  ): EntityType.AsProtobufJSON {\n    return {\n      name: this.name,\n      displayName: this.displayName,\n      kind:\n        EntityType.Kind[\n          this.kind === null || this.kind === undefined ? 0 : this.kind\n        ],\n      autoExpansionMode:\n        EntityType.AutoExpansionMode[\n          this.autoExpansionMode === null ||\n          this.autoExpansionMode === undefined\n            ? 0\n            : this.autoExpansionMode\n        ],\n      entities: (this.entities || []).map(m => m.toProtobufJSON(options)),\n      nextPageToken: this.nextPageToken,\n      entityCount: this.entityCount,\n      status:\n        EntityType.EntityTypeStatus[\n          this.status === null || this.status === undefined ? 0 : this.status\n        ],\n      synonymCount: this.synonymCount\n    };\n  }\n}\nexport module EntityType {\n  /**\n   * Standard JavaScript object representation for EntityType\n   */\n  export interface AsObject {\n    name?: string;\n    displayName?: string;\n    kind?: EntityType.Kind;\n    autoExpansionMode?: EntityType.AutoExpansionMode;\n    entities?: EntityType.Entity.AsObject[];\n    nextPageToken?: string;\n    entityCount?: number;\n    status?: EntityType.EntityTypeStatus;\n    synonymCount?: number;\n  }\n\n  /**\n   * Protobuf JSON representation for EntityType\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n    displayName?: string;\n    kind?: string;\n    autoExpansionMode?: string;\n    entities?: EntityType.Entity.AsProtobufJSON[] | null;\n    nextPageToken?: string;\n    entityCount?: number;\n    status?: string;\n    synonymCount?: number;\n  }\n  export enum Kind {\n    KIND_UNSPECIFIED = 0,\n    KIND_MAP = 1,\n    KIND_LIST = 2\n  }\n  export enum EntityTypeStatus {\n    ACTIVE = 0,\n    INACTIVE = 1\n  }\n  export enum AutoExpansionMode {\n    AUTO_EXPANSION_MODE_UNSPECIFIED = 0,\n    AUTO_EXPANSION_MODE_DEFAULT = 1\n  }\n  /**\n   * Message implementation for ondewo.nlu.Entity\n   */\n  export class Entity implements GrpcMessage {\n    static id = 'ondewo.nlu.Entity';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new Entity();\n      Entity.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: Entity) {\n      _instance.value = _instance.value || '';\n      _instance.synonyms = _instance.synonyms || [];\n      _instance.name = _instance.name || '';\n      _instance.displayName = _instance.displayName || '';\n      _instance.synonymCount = _instance.synonymCount || 0;\n      _instance.languageCode = _instance.languageCode || '';\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: Entity,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.value = _reader.readString();\n            break;\n          case 2:\n            (_instance.synonyms = _instance.synonyms || []).push(\n              _reader.readString()\n            );\n            break;\n          case 3:\n            _instance.name = _reader.readString();\n            break;\n          case 4:\n            _instance.displayName = _reader.readString();\n            break;\n          case 5:\n            _instance.synonymCount = _reader.readInt32();\n            break;\n          case 6:\n            _instance.languageCode = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      Entity.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: Entity, _writer: BinaryWriter) {\n      if (_instance.value) {\n        _writer.writeString(1, _instance.value);\n      }\n      if (_instance.synonyms && _instance.synonyms.length) {\n        _writer.writeRepeatedString(2, _instance.synonyms);\n      }\n      if (_instance.name) {\n        _writer.writeString(3, _instance.name);\n      }\n      if (_instance.displayName) {\n        _writer.writeString(4, _instance.displayName);\n      }\n      if (_instance.synonymCount) {\n        _writer.writeInt32(5, _instance.synonymCount);\n      }\n      if (_instance.languageCode) {\n        _writer.writeString(6, _instance.languageCode);\n      }\n    }\n\n    private _value?: string;\n    private _synonyms?: string[];\n    private _name?: string;\n    private _displayName?: string;\n    private _synonymCount?: number;\n    private _languageCode?: 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 Entity to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Entity.AsObject>) {\n      _value = _value || {};\n      this.value = _value.value;\n      this.synonyms = (_value.synonyms || []).slice();\n      this.name = _value.name;\n      this.displayName = _value.displayName;\n      this.synonymCount = _value.synonymCount;\n      this.languageCode = _value.languageCode;\n      Entity.refineValues(this);\n    }\n    get value(): string | undefined {\n      return this._value;\n    }\n    set value(value: string | undefined) {\n      this._value = value;\n    }\n    get synonyms(): string[] | undefined {\n      return this._synonyms;\n    }\n    set synonyms(value: string[] | undefined) {\n      this._synonyms = 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 displayName(): string | undefined {\n      return this._displayName;\n    }\n    set displayName(value: string | undefined) {\n      this._displayName = value;\n    }\n    get synonymCount(): number | undefined {\n      return this._synonymCount;\n    }\n    set synonymCount(value: number | undefined) {\n      this._synonymCount = value;\n    }\n    get languageCode(): string | undefined {\n      return this._languageCode;\n    }\n    set languageCode(value: string | undefined) {\n      this._languageCode = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      Entity.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(): Entity.AsObject {\n      return {\n        value: this.value,\n        synonyms: (this.synonyms || []).slice(),\n        name: this.name,\n        displayName: this.displayName,\n        synonymCount: this.synonymCount,\n        languageCode: this.languageCode\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    ): Entity.AsProtobufJSON {\n      return {\n        value: this.value,\n        synonyms: (this.synonyms || []).slice(),\n        name: this.name,\n        displayName: this.displayName,\n        synonymCount: this.synonymCount,\n        languageCode: this.languageCode\n      };\n    }\n  }\n  export module Entity {\n    /**\n     * Standard JavaScript object representation for Entity\n     */\n    export interface AsObject {\n      value?: string;\n      synonyms?: string[];\n      name?: string;\n      displayName?: string;\n      synonymCount?: number;\n      languageCode?: string;\n    }\n\n    /**\n     * Protobuf JSON representation for Entity\n     */\n    export interface AsProtobufJSON {\n      value?: string;\n      synonyms?: string[];\n      name?: string;\n      displayName?: string;\n      synonymCount?: number;\n      languageCode?: string;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListEntityTypesRequest\n */\nexport class ListEntityTypesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListEntityTypesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListEntityTypesRequest();\n    ListEntityTypesRequest.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: ListEntityTypesRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.pageToken = _instance.pageToken || '';\n    _instance.entityTypeView = _instance.entityTypeView || 0;\n    _instance.filterByCategory = _instance.filterByCategory || 0;\n    _instance.sortByField = _instance.sortByField || 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: ListEntityTypesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.parent = _reader.readString();\n          break;\n        case 2:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 4:\n          _instance.pageToken = _reader.readString();\n          break;\n        case 5:\n          _instance.entityTypeView = _reader.readEnum();\n          break;\n        case 6:\n          _instance.filterByCategory = _reader.readEnum();\n          break;\n        case 7:\n          _instance.sortByField = new EntityTypeSorting();\n          _reader.readMessage(\n            _instance.sortByField,\n            EntityTypeSorting.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListEntityTypesRequest.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: ListEntityTypesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.pageToken) {\n      _writer.writeString(4, _instance.pageToken);\n    }\n    if (_instance.entityTypeView) {\n      _writer.writeEnum(5, _instance.entityTypeView);\n    }\n    if (_instance.filterByCategory) {\n      _writer.writeEnum(6, _instance.filterByCategory);\n    }\n    if (_instance.sortByField) {\n      _writer.writeMessage(\n        7,\n        _instance.sortByField as any,\n        EntityTypeSorting.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _parent?: string;\n  private _languageCode?: string;\n  private _pageToken?: string;\n  private _entityTypeView?: EntityTypeView;\n  private _filterByCategory?: EntityTypeCategory;\n  private _sortByField?: EntityTypeSorting;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListEntityTypesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListEntityTypesRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.languageCode = _value.languageCode;\n    this.pageToken = _value.pageToken;\n    this.entityTypeView = _value.entityTypeView;\n    this.filterByCategory = _value.filterByCategory;\n    this.sortByField = _value.sortByField\n      ? new EntityTypeSorting(_value.sortByField)\n      : undefined;\n    ListEntityTypesRequest.refineValues(this);\n  }\n  get parent(): string | undefined {\n    return this._parent;\n  }\n  set parent(value: string | undefined) {\n    this._parent = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get pageToken(): string | undefined {\n    return this._pageToken;\n  }\n  set pageToken(value: string | undefined) {\n    this._pageToken = value;\n  }\n  get entityTypeView(): EntityTypeView | undefined {\n    return this._entityTypeView;\n  }\n  set entityTypeView(value: EntityTypeView | undefined) {\n    this._entityTypeView = value;\n  }\n  get filterByCategory(): EntityTypeCategory | undefined {\n    return this._filterByCategory;\n  }\n  set filterByCategory(value: EntityTypeCategory | undefined) {\n    this._filterByCategory = value;\n  }\n  get sortByField(): EntityTypeSorting | undefined {\n    return this._sortByField;\n  }\n  set sortByField(value: EntityTypeSorting | undefined) {\n    this._sortByField = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListEntityTypesRequest.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(): ListEntityTypesRequest.AsObject {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      pageToken: this.pageToken,\n      entityTypeView: this.entityTypeView,\n      filterByCategory: this.filterByCategory,\n      sortByField: this.sortByField ? this.sortByField.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  ): ListEntityTypesRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      pageToken: this.pageToken,\n      entityTypeView:\n        EntityTypeView[\n          this.entityTypeView === null || this.entityTypeView === undefined\n            ? 0\n            : this.entityTypeView\n        ],\n      filterByCategory:\n        EntityTypeCategory[\n          this.filterByCategory === null || this.filterByCategory === undefined\n            ? 0\n            : this.filterByCategory\n        ],\n      sortByField: this.sortByField\n        ? this.sortByField.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module ListEntityTypesRequest {\n  /**\n   * Standard JavaScript object representation for ListEntityTypesRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    languageCode?: string;\n    pageToken?: string;\n    entityTypeView?: EntityTypeView;\n    filterByCategory?: EntityTypeCategory;\n    sortByField?: EntityTypeSorting.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ListEntityTypesRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    languageCode?: string;\n    pageToken?: string;\n    entityTypeView?: string;\n    filterByCategory?: string;\n    sortByField?: EntityTypeSorting.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListEntityTypesResponse\n */\nexport class ListEntityTypesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListEntityTypesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListEntityTypesResponse();\n    ListEntityTypesResponse.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: ListEntityTypesResponse) {\n    _instance.entityTypes = _instance.entityTypes || [];\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: ListEntityTypesResponse,\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 EntityType();\n          _reader.readMessage(\n            messageInitializer1,\n            EntityType.deserializeBinaryFromReader\n          );\n          (_instance.entityTypes = _instance.entityTypes || []).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    ListEntityTypesResponse.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: ListEntityTypesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityTypes && _instance.entityTypes.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.entityTypes as any,\n        EntityType.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _entityTypes?: EntityType[];\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 ListEntityTypesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListEntityTypesResponse.AsObject>) {\n    _value = _value || {};\n    this.entityTypes = (_value.entityTypes || []).map(m => new EntityType(m));\n    this.nextPageToken = _value.nextPageToken;\n    ListEntityTypesResponse.refineValues(this);\n  }\n  get entityTypes(): EntityType[] | undefined {\n    return this._entityTypes;\n  }\n  set entityTypes(value: EntityType[] | undefined) {\n    this._entityTypes = 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    ListEntityTypesResponse.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(): ListEntityTypesResponse.AsObject {\n    return {\n      entityTypes: (this.entityTypes || []).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  ): ListEntityTypesResponse.AsProtobufJSON {\n    return {\n      entityTypes: (this.entityTypes || []).map(m => m.toProtobufJSON(options)),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListEntityTypesResponse {\n  /**\n   * Standard JavaScript object representation for ListEntityTypesResponse\n   */\n  export interface AsObject {\n    entityTypes?: EntityType.AsObject[];\n    nextPageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListEntityTypesResponse\n   */\n  export interface AsProtobufJSON {\n    entityTypes?: EntityType.AsProtobufJSON[] | null;\n    nextPageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetEntityTypeRequest\n */\nexport class GetEntityTypeRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetEntityTypeRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetEntityTypeRequest();\n    GetEntityTypeRequest.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: GetEntityTypeRequest) {\n    _instance.name = _instance.name || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.pageToken = _instance.pageToken || '';\n    _instance.entityTypeView = _instance.entityTypeView || 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: GetEntityTypeRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        case 2:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 5:\n          _instance.pageToken = _reader.readString();\n          break;\n        case 6:\n          _instance.entityTypeView = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetEntityTypeRequest.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: GetEntityTypeRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.pageToken) {\n      _writer.writeString(5, _instance.pageToken);\n    }\n    if (_instance.entityTypeView) {\n      _writer.writeEnum(6, _instance.entityTypeView);\n    }\n  }\n\n  private _name?: string;\n  private _languageCode?: string;\n  private _pageToken?: string;\n  private _entityTypeView?: EntityTypeView;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetEntityTypeRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetEntityTypeRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.languageCode = _value.languageCode;\n    this.pageToken = _value.pageToken;\n    this.entityTypeView = _value.entityTypeView;\n    GetEntityTypeRequest.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get pageToken(): string | undefined {\n    return this._pageToken;\n  }\n  set pageToken(value: string | undefined) {\n    this._pageToken = value;\n  }\n  get entityTypeView(): EntityTypeView | undefined {\n    return this._entityTypeView;\n  }\n  set entityTypeView(value: EntityTypeView | undefined) {\n    this._entityTypeView = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetEntityTypeRequest.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(): GetEntityTypeRequest.AsObject {\n    return {\n      name: this.name,\n      languageCode: this.languageCode,\n      pageToken: this.pageToken,\n      entityTypeView: this.entityTypeView\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  ): GetEntityTypeRequest.AsProtobufJSON {\n    return {\n      name: this.name,\n      languageCode: this.languageCode,\n      pageToken: this.pageToken,\n      entityTypeView:\n        EntityTypeView[\n          this.entityTypeView === null || this.entityTypeView === undefined\n            ? 0\n            : this.entityTypeView\n        ]\n    };\n  }\n}\nexport module GetEntityTypeRequest {\n  /**\n   * Standard JavaScript object representation for GetEntityTypeRequest\n   */\n  export interface AsObject {\n    name?: string;\n    languageCode?: string;\n    pageToken?: string;\n    entityTypeView?: EntityTypeView;\n  }\n\n  /**\n   * Protobuf JSON representation for GetEntityTypeRequest\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n    languageCode?: string;\n    pageToken?: string;\n    entityTypeView?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CreateEntityTypeRequest\n */\nexport class CreateEntityTypeRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CreateEntityTypeRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CreateEntityTypeRequest();\n    CreateEntityTypeRequest.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: CreateEntityTypeRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.entityType = _instance.entityType || undefined;\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.entityTypeView = _instance.entityTypeView || 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: CreateEntityTypeRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.parent = _reader.readString();\n          break;\n        case 2:\n          _instance.entityType = new EntityType();\n          _reader.readMessage(\n            _instance.entityType,\n            EntityType.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 6:\n          _instance.entityTypeView = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CreateEntityTypeRequest.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: CreateEntityTypeRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.entityType) {\n      _writer.writeMessage(\n        2,\n        _instance.entityType as any,\n        EntityType.serializeBinaryToWriter\n      );\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(3, _instance.languageCode);\n    }\n    if (_instance.entityTypeView) {\n      _writer.writeEnum(6, _instance.entityTypeView);\n    }\n  }\n\n  private _parent?: string;\n  private _entityType?: EntityType;\n  private _languageCode?: string;\n  private _entityTypeView?: EntityTypeView;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CreateEntityTypeRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CreateEntityTypeRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.entityType = _value.entityType\n      ? new EntityType(_value.entityType)\n      : undefined;\n    this.languageCode = _value.languageCode;\n    this.entityTypeView = _value.entityTypeView;\n    CreateEntityTypeRequest.refineValues(this);\n  }\n  get parent(): string | undefined {\n    return this._parent;\n  }\n  set parent(value: string | undefined) {\n    this._parent = value;\n  }\n  get entityType(): EntityType | undefined {\n    return this._entityType;\n  }\n  set entityType(value: EntityType | undefined) {\n    this._entityType = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get entityTypeView(): EntityTypeView | undefined {\n    return this._entityTypeView;\n  }\n  set entityTypeView(value: EntityTypeView | undefined) {\n    this._entityTypeView = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CreateEntityTypeRequest.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(): CreateEntityTypeRequest.AsObject {\n    return {\n      parent: this.parent,\n      entityType: this.entityType ? this.entityType.toObject() : undefined,\n      languageCode: this.languageCode,\n      entityTypeView: this.entityTypeView\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  ): CreateEntityTypeRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      entityType: this.entityType\n        ? this.entityType.toProtobufJSON(options)\n        : null,\n      languageCode: this.languageCode,\n      entityTypeView:\n        EntityTypeView[\n          this.entityTypeView === null || this.entityTypeView === undefined\n            ? 0\n            : this.entityTypeView\n        ]\n    };\n  }\n}\nexport module CreateEntityTypeRequest {\n  /**\n   * Standard JavaScript object representation for CreateEntityTypeRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    entityType?: EntityType.AsObject;\n    languageCode?: string;\n    entityTypeView?: EntityTypeView;\n  }\n\n  /**\n   * Protobuf JSON representation for CreateEntityTypeRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    entityType?: EntityType.AsProtobufJSON | null;\n    languageCode?: string;\n    entityTypeView?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.UpdateEntityTypeRequest\n */\nexport class UpdateEntityTypeRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.UpdateEntityTypeRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new UpdateEntityTypeRequest();\n    UpdateEntityTypeRequest.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: UpdateEntityTypeRequest) {\n    _instance.entityType = _instance.entityType || undefined;\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.updateMask = _instance.updateMask || undefined;\n    _instance.entityTypeView = _instance.entityTypeView || 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: UpdateEntityTypeRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.entityType = new EntityType();\n          _reader.readMessage(\n            _instance.entityType,\n            EntityType.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 3:\n          _instance.updateMask = new googleProtobuf008.FieldMask();\n          _reader.readMessage(\n            _instance.updateMask,\n            googleProtobuf008.FieldMask.deserializeBinaryFromReader\n          );\n          break;\n        case 6:\n          _instance.entityTypeView = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    UpdateEntityTypeRequest.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: UpdateEntityTypeRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityType) {\n      _writer.writeMessage(\n        1,\n        _instance.entityType as any,\n        EntityType.serializeBinaryToWriter\n      );\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.updateMask) {\n      _writer.writeMessage(\n        3,\n        _instance.updateMask as any,\n        googleProtobuf008.FieldMask.serializeBinaryToWriter\n      );\n    }\n    if (_instance.entityTypeView) {\n      _writer.writeEnum(6, _instance.entityTypeView);\n    }\n  }\n\n  private _entityType?: EntityType;\n  private _languageCode?: string;\n  private _updateMask?: googleProtobuf008.FieldMask;\n  private _entityTypeView?: EntityTypeView;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of UpdateEntityTypeRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<UpdateEntityTypeRequest.AsObject>) {\n    _value = _value || {};\n    this.entityType = _value.entityType\n      ? new EntityType(_value.entityType)\n      : undefined;\n    this.languageCode = _value.languageCode;\n    this.updateMask = _value.updateMask\n      ? new googleProtobuf008.FieldMask(_value.updateMask)\n      : undefined;\n    this.entityTypeView = _value.entityTypeView;\n    UpdateEntityTypeRequest.refineValues(this);\n  }\n  get entityType(): EntityType | undefined {\n    return this._entityType;\n  }\n  set entityType(value: EntityType | undefined) {\n    this._entityType = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get updateMask(): googleProtobuf008.FieldMask | undefined {\n    return this._updateMask;\n  }\n  set updateMask(value: googleProtobuf008.FieldMask | undefined) {\n    this._updateMask = value;\n  }\n  get entityTypeView(): EntityTypeView | undefined {\n    return this._entityTypeView;\n  }\n  set entityTypeView(value: EntityTypeView | undefined) {\n    this._entityTypeView = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    UpdateEntityTypeRequest.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(): UpdateEntityTypeRequest.AsObject {\n    return {\n      entityType: this.entityType ? this.entityType.toObject() : undefined,\n      languageCode: this.languageCode,\n      updateMask: this.updateMask ? this.updateMask.toObject() : undefined,\n      entityTypeView: this.entityTypeView\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  ): UpdateEntityTypeRequest.AsProtobufJSON {\n    return {\n      entityType: this.entityType\n        ? this.entityType.toProtobufJSON(options)\n        : null,\n      languageCode: this.languageCode,\n      updateMask: this.updateMask\n        ? this.updateMask.toProtobufJSON(options)\n        : null,\n      entityTypeView:\n        EntityTypeView[\n          this.entityTypeView === null || this.entityTypeView === undefined\n            ? 0\n            : this.entityTypeView\n        ]\n    };\n  }\n}\nexport module UpdateEntityTypeRequest {\n  /**\n   * Standard JavaScript object representation for UpdateEntityTypeRequest\n   */\n  export interface AsObject {\n    entityType?: EntityType.AsObject;\n    languageCode?: string;\n    updateMask?: googleProtobuf008.FieldMask.AsObject;\n    entityTypeView?: EntityTypeView;\n  }\n\n  /**\n   * Protobuf JSON representation for UpdateEntityTypeRequest\n   */\n  export interface AsProtobufJSON {\n    entityType?: EntityType.AsProtobufJSON | null;\n    languageCode?: string;\n    updateMask?: googleProtobuf008.FieldMask.AsProtobufJSON | null;\n    entityTypeView?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.DeleteEntityTypeRequest\n */\nexport class DeleteEntityTypeRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.DeleteEntityTypeRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new DeleteEntityTypeRequest();\n    DeleteEntityTypeRequest.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: DeleteEntityTypeRequest) {\n    _instance.name = _instance.name || '';\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: DeleteEntityTypeRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    DeleteEntityTypeRequest.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: DeleteEntityTypeRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n  }\n\n  private _name?: 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 DeleteEntityTypeRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<DeleteEntityTypeRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    DeleteEntityTypeRequest.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    DeleteEntityTypeRequest.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(): DeleteEntityTypeRequest.AsObject {\n    return {\n      name: this.name\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  ): DeleteEntityTypeRequest.AsProtobufJSON {\n    return {\n      name: this.name\n    };\n  }\n}\nexport module DeleteEntityTypeRequest {\n  /**\n   * Standard JavaScript object representation for DeleteEntityTypeRequest\n   */\n  export interface AsObject {\n    name?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for DeleteEntityTypeRequest\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchUpdateEntityTypesRequest\n */\nexport class BatchUpdateEntityTypesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchUpdateEntityTypesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchUpdateEntityTypesRequest();\n    BatchUpdateEntityTypesRequest.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: BatchUpdateEntityTypesRequest) {\n    _instance.parent = _instance.parent || '';\n\n    _instance.languageCode = _instance.languageCode || '';\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: BatchUpdateEntityTypesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.parent = _reader.readString();\n          break;\n        case 2:\n          _instance.entityTypeBatchUri = _reader.readString();\n          break;\n        case 3:\n          _instance.entityTypeBatchInline = new EntityTypeBatch();\n          _reader.readMessage(\n            _instance.entityTypeBatchInline,\n            EntityTypeBatch.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 5:\n          _instance.updateMask = new googleProtobuf008.FieldMask();\n          _reader.readMessage(\n            _instance.updateMask,\n            googleProtobuf008.FieldMask.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchUpdateEntityTypesRequest.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: BatchUpdateEntityTypesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.entityTypeBatchUri || _instance.entityTypeBatchUri === '') {\n      _writer.writeString(2, _instance.entityTypeBatchUri);\n    }\n    if (_instance.entityTypeBatchInline) {\n      _writer.writeMessage(\n        3,\n        _instance.entityTypeBatchInline as any,\n        EntityTypeBatch.serializeBinaryToWriter\n      );\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(4, _instance.languageCode);\n    }\n    if (_instance.updateMask) {\n      _writer.writeMessage(\n        5,\n        _instance.updateMask as any,\n        googleProtobuf008.FieldMask.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _parent?: string;\n  private _entityTypeBatchUri?: string;\n  private _entityTypeBatchInline?: EntityTypeBatch;\n  private _languageCode?: string;\n  private _updateMask?: googleProtobuf008.FieldMask;\n\n  private _entityTypeBatch: BatchUpdateEntityTypesRequest.EntityTypeBatchCase =\n    BatchUpdateEntityTypesRequest.EntityTypeBatchCase.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 BatchUpdateEntityTypesRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<BatchUpdateEntityTypesRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.entityTypeBatchUri = _value.entityTypeBatchUri;\n    this.entityTypeBatchInline = _value.entityTypeBatchInline\n      ? new EntityTypeBatch(_value.entityTypeBatchInline)\n      : undefined;\n    this.languageCode = _value.languageCode;\n    this.updateMask = _value.updateMask\n      ? new googleProtobuf008.FieldMask(_value.updateMask)\n      : undefined;\n    BatchUpdateEntityTypesRequest.refineValues(this);\n  }\n  get parent(): string | undefined {\n    return this._parent;\n  }\n  set parent(value: string | undefined) {\n    this._parent = value;\n  }\n  get entityTypeBatchUri(): string | undefined {\n    return this._entityTypeBatchUri;\n  }\n  set entityTypeBatchUri(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._entityTypeBatchInline = undefined;\n      this._entityTypeBatch =\n        BatchUpdateEntityTypesRequest.EntityTypeBatchCase.entityTypeBatchUri;\n    }\n    this._entityTypeBatchUri = value;\n  }\n  get entityTypeBatchInline(): EntityTypeBatch | undefined {\n    return this._entityTypeBatchInline;\n  }\n  set entityTypeBatchInline(value: EntityTypeBatch | undefined) {\n    if (value !== undefined && value !== null) {\n      this._entityTypeBatchUri = undefined;\n      this._entityTypeBatch =\n        BatchUpdateEntityTypesRequest.EntityTypeBatchCase.entityTypeBatchInline;\n    }\n    this._entityTypeBatchInline = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get updateMask(): googleProtobuf008.FieldMask | undefined {\n    return this._updateMask;\n  }\n  set updateMask(value: googleProtobuf008.FieldMask | undefined) {\n    this._updateMask = value;\n  }\n  get entityTypeBatch() {\n    return this._entityTypeBatch;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchUpdateEntityTypesRequest.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(): BatchUpdateEntityTypesRequest.AsObject {\n    return {\n      parent: this.parent,\n      entityTypeBatchUri: this.entityTypeBatchUri,\n      entityTypeBatchInline: this.entityTypeBatchInline\n        ? this.entityTypeBatchInline.toObject()\n        : undefined,\n      languageCode: this.languageCode,\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  ): BatchUpdateEntityTypesRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      entityTypeBatchUri:\n        this.entityTypeBatchUri === null ||\n        this.entityTypeBatchUri === undefined\n          ? null\n          : this.entityTypeBatchUri,\n      entityTypeBatchInline: this.entityTypeBatchInline\n        ? this.entityTypeBatchInline.toProtobufJSON(options)\n        : null,\n      languageCode: this.languageCode,\n      updateMask: this.updateMask\n        ? this.updateMask.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module BatchUpdateEntityTypesRequest {\n  /**\n   * Standard JavaScript object representation for BatchUpdateEntityTypesRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    entityTypeBatchUri?: string;\n    entityTypeBatchInline?: EntityTypeBatch.AsObject;\n    languageCode?: string;\n    updateMask?: googleProtobuf008.FieldMask.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for BatchUpdateEntityTypesRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    entityTypeBatchUri?: string | null;\n    entityTypeBatchInline?: EntityTypeBatch.AsProtobufJSON | null;\n    languageCode?: string;\n    updateMask?: googleProtobuf008.FieldMask.AsProtobufJSON | null;\n  }\n  export enum EntityTypeBatchCase {\n    none = 0,\n    entityTypeBatchUri = 1,\n    entityTypeBatchInline = 2\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchUpdateEntityTypesResponse\n */\nexport class BatchUpdateEntityTypesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchUpdateEntityTypesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchUpdateEntityTypesResponse();\n    BatchUpdateEntityTypesResponse.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: BatchUpdateEntityTypesResponse) {\n    _instance.entityTypes = _instance.entityTypes || [];\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: BatchUpdateEntityTypesResponse,\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 EntityType();\n          _reader.readMessage(\n            messageInitializer1,\n            EntityType.deserializeBinaryFromReader\n          );\n          (_instance.entityTypes = _instance.entityTypes || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchUpdateEntityTypesResponse.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: BatchUpdateEntityTypesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityTypes && _instance.entityTypes.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.entityTypes as any,\n        EntityType.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _entityTypes?: EntityType[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of BatchUpdateEntityTypesResponse to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<BatchUpdateEntityTypesResponse.AsObject>\n  ) {\n    _value = _value || {};\n    this.entityTypes = (_value.entityTypes || []).map(m => new EntityType(m));\n    BatchUpdateEntityTypesResponse.refineValues(this);\n  }\n  get entityTypes(): EntityType[] | undefined {\n    return this._entityTypes;\n  }\n  set entityTypes(value: EntityType[] | undefined) {\n    this._entityTypes = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchUpdateEntityTypesResponse.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(): BatchUpdateEntityTypesResponse.AsObject {\n    return {\n      entityTypes: (this.entityTypes || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): BatchUpdateEntityTypesResponse.AsProtobufJSON {\n    return {\n      entityTypes: (this.entityTypes || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module BatchUpdateEntityTypesResponse {\n  /**\n   * Standard JavaScript object representation for BatchUpdateEntityTypesResponse\n   */\n  export interface AsObject {\n    entityTypes?: EntityType.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for BatchUpdateEntityTypesResponse\n   */\n  export interface AsProtobufJSON {\n    entityTypes?: EntityType.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchDeleteEntityTypesRequest\n */\nexport class BatchDeleteEntityTypesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchDeleteEntityTypesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchDeleteEntityTypesRequest();\n    BatchDeleteEntityTypesRequest.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: BatchDeleteEntityTypesRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.entityTypeNames = _instance.entityTypeNames || [];\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: BatchDeleteEntityTypesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.parent = _reader.readString();\n          break;\n        case 2:\n          (_instance.entityTypeNames = _instance.entityTypeNames || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchDeleteEntityTypesRequest.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: BatchDeleteEntityTypesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.entityTypeNames && _instance.entityTypeNames.length) {\n      _writer.writeRepeatedString(2, _instance.entityTypeNames);\n    }\n  }\n\n  private _parent?: string;\n  private _entityTypeNames?: 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 BatchDeleteEntityTypesRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<BatchDeleteEntityTypesRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.entityTypeNames = (_value.entityTypeNames || []).slice();\n    BatchDeleteEntityTypesRequest.refineValues(this);\n  }\n  get parent(): string | undefined {\n    return this._parent;\n  }\n  set parent(value: string | undefined) {\n    this._parent = value;\n  }\n  get entityTypeNames(): string[] | undefined {\n    return this._entityTypeNames;\n  }\n  set entityTypeNames(value: string[] | undefined) {\n    this._entityTypeNames = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchDeleteEntityTypesRequest.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(): BatchDeleteEntityTypesRequest.AsObject {\n    return {\n      parent: this.parent,\n      entityTypeNames: (this.entityTypeNames || []).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  ): BatchDeleteEntityTypesRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      entityTypeNames: (this.entityTypeNames || []).slice()\n    };\n  }\n}\nexport module BatchDeleteEntityTypesRequest {\n  /**\n   * Standard JavaScript object representation for BatchDeleteEntityTypesRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    entityTypeNames?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for BatchDeleteEntityTypesRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    entityTypeNames?: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.EntityTypeBatch\n */\nexport class EntityTypeBatch implements GrpcMessage {\n  static id = 'ondewo.nlu.EntityTypeBatch';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new EntityTypeBatch();\n    EntityTypeBatch.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: EntityTypeBatch) {\n    _instance.entityTypes = _instance.entityTypes || [];\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: EntityTypeBatch,\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 EntityType();\n          _reader.readMessage(\n            messageInitializer1,\n            EntityType.deserializeBinaryFromReader\n          );\n          (_instance.entityTypes = _instance.entityTypes || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    EntityTypeBatch.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: EntityTypeBatch,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityTypes && _instance.entityTypes.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.entityTypes as any,\n        EntityType.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _entityTypes?: EntityType[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of EntityTypeBatch to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<EntityTypeBatch.AsObject>) {\n    _value = _value || {};\n    this.entityTypes = (_value.entityTypes || []).map(m => new EntityType(m));\n    EntityTypeBatch.refineValues(this);\n  }\n  get entityTypes(): EntityType[] | undefined {\n    return this._entityTypes;\n  }\n  set entityTypes(value: EntityType[] | undefined) {\n    this._entityTypes = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    EntityTypeBatch.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(): EntityTypeBatch.AsObject {\n    return {\n      entityTypes: (this.entityTypes || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): EntityTypeBatch.AsProtobufJSON {\n    return {\n      entityTypes: (this.entityTypes || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module EntityTypeBatch {\n  /**\n   * Standard JavaScript object representation for EntityTypeBatch\n   */\n  export interface AsObject {\n    entityTypes?: EntityType.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for EntityTypeBatch\n   */\n  export interface AsProtobufJSON {\n    entityTypes?: EntityType.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.EntityTypeSorting\n */\nexport class EntityTypeSorting implements GrpcMessage {\n  static id = 'ondewo.nlu.EntityTypeSorting';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new EntityTypeSorting();\n    EntityTypeSorting.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: EntityTypeSorting) {\n    _instance.sortingField = _instance.sortingField || 0;\n    _instance.sortingMode = _instance.sortingMode || 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: EntityTypeSorting,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.sortingField = _reader.readEnum();\n          break;\n        case 2:\n          _instance.sortingMode = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    EntityTypeSorting.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: EntityTypeSorting,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.sortingField) {\n      _writer.writeEnum(1, _instance.sortingField);\n    }\n    if (_instance.sortingMode) {\n      _writer.writeEnum(2, _instance.sortingMode);\n    }\n  }\n\n  private _sortingField?: EntityTypeSorting.EntityTypeSortingField;\n  private _sortingMode?: ondewoNlu009.SortingMode;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of EntityTypeSorting to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<EntityTypeSorting.AsObject>) {\n    _value = _value || {};\n    this.sortingField = _value.sortingField;\n    this.sortingMode = _value.sortingMode;\n    EntityTypeSorting.refineValues(this);\n  }\n  get sortingField(): EntityTypeSorting.EntityTypeSortingField | undefined {\n    return this._sortingField;\n  }\n  set sortingField(\n    value: EntityTypeSorting.EntityTypeSortingField | undefined\n  ) {\n    this._sortingField = value;\n  }\n  get sortingMode(): ondewoNlu009.SortingMode | undefined {\n    return this._sortingMode;\n  }\n  set sortingMode(value: ondewoNlu009.SortingMode | undefined) {\n    this._sortingMode = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    EntityTypeSorting.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(): EntityTypeSorting.AsObject {\n    return {\n      sortingField: this.sortingField,\n      sortingMode: this.sortingMode\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  ): EntityTypeSorting.AsProtobufJSON {\n    return {\n      sortingField:\n        EntityTypeSorting.EntityTypeSortingField[\n          this.sortingField === null || this.sortingField === undefined\n            ? 0\n            : this.sortingField\n        ],\n      sortingMode:\n        ondewoNlu009.SortingMode[\n          this.sortingMode === null || this.sortingMode === undefined\n            ? 0\n            : this.sortingMode\n        ]\n    };\n  }\n}\nexport module EntityTypeSorting {\n  /**\n   * Standard JavaScript object representation for EntityTypeSorting\n   */\n  export interface AsObject {\n    sortingField?: EntityTypeSorting.EntityTypeSortingField;\n    sortingMode?: ondewoNlu009.SortingMode;\n  }\n\n  /**\n   * Protobuf JSON representation for EntityTypeSorting\n   */\n  export interface AsProtobufJSON {\n    sortingField?: string;\n    sortingMode?: string;\n  }\n  export enum EntityTypeSortingField {\n    NO_ENTITY_TYPE_SORTING = 0,\n    SORT_ENTITY_TYPE_BY_NAME = 1,\n    SORT_ENTITY_TYPE_BY_CREATION_DATE = 2,\n    SORT_ENTITY_TYPE_BY_LAST_UPDATED = 3,\n    SORT_ENTITY_TYPE_BY_ENTITY_VALUE_COUNT = 4,\n    SORT_ENTITY_TYPE_BY_SYNONYM_COUNT = 5\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchEntitiesResponse\n */\nexport class BatchEntitiesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchEntitiesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchEntitiesResponse();\n    BatchEntitiesResponse.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: BatchEntitiesResponse) {\n    _instance.entityStatuses = _instance.entityStatuses || [];\n    _instance.hasErrors = _instance.hasErrors || false;\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: BatchEntitiesResponse,\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 BatchEntitiesResponse.EntityStatus();\n          _reader.readMessage(\n            messageInitializer1,\n            BatchEntitiesResponse.EntityStatus.deserializeBinaryFromReader\n          );\n          (_instance.entityStatuses = _instance.entityStatuses || []).push(\n            messageInitializer1\n          );\n          break;\n        case 2:\n          _instance.hasErrors = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchEntitiesResponse.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: BatchEntitiesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityStatuses && _instance.entityStatuses.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.entityStatuses as any,\n        BatchEntitiesResponse.EntityStatus.serializeBinaryToWriter\n      );\n    }\n    if (_instance.hasErrors) {\n      _writer.writeBool(2, _instance.hasErrors);\n    }\n  }\n\n  private _entityStatuses?: BatchEntitiesResponse.EntityStatus[];\n  private _hasErrors?: boolean;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of BatchEntitiesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<BatchEntitiesResponse.AsObject>) {\n    _value = _value || {};\n    this.entityStatuses = (_value.entityStatuses || []).map(\n      m => new BatchEntitiesResponse.EntityStatus(m)\n    );\n    this.hasErrors = _value.hasErrors;\n    BatchEntitiesResponse.refineValues(this);\n  }\n  get entityStatuses(): BatchEntitiesResponse.EntityStatus[] | undefined {\n    return this._entityStatuses;\n  }\n  set entityStatuses(value: BatchEntitiesResponse.EntityStatus[] | undefined) {\n    this._entityStatuses = value;\n  }\n  get hasErrors(): boolean | undefined {\n    return this._hasErrors;\n  }\n  set hasErrors(value: boolean | undefined) {\n    this._hasErrors = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchEntitiesResponse.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(): BatchEntitiesResponse.AsObject {\n    return {\n      entityStatuses: (this.entityStatuses || []).map(m => m.toObject()),\n      hasErrors: this.hasErrors\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  ): BatchEntitiesResponse.AsProtobufJSON {\n    return {\n      entityStatuses: (this.entityStatuses || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      hasErrors: this.hasErrors\n    };\n  }\n}\nexport module BatchEntitiesResponse {\n  /**\n   * Standard JavaScript object representation for BatchEntitiesResponse\n   */\n  export interface AsObject {\n    entityStatuses?: BatchEntitiesResponse.EntityStatus.AsObject[];\n    hasErrors?: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for BatchEntitiesResponse\n   */\n  export interface AsProtobufJSON {\n    entityStatuses?: BatchEntitiesResponse.EntityStatus.AsProtobufJSON[] | null;\n    hasErrors?: boolean;\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.EntityStatus\n   */\n  export class EntityStatus implements GrpcMessage {\n    static id = 'ondewo.nlu.EntityStatus';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new EntityStatus();\n      EntityStatus.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: EntityStatus) {}\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: EntityStatus,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.entity = new EntityType.Entity();\n            _reader.readMessage(\n              _instance.entity,\n              EntityType.Entity.deserializeBinaryFromReader\n            );\n            break;\n          case 2:\n            _instance.errorMessage = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      EntityStatus.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: EntityStatus,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.entity) {\n        _writer.writeMessage(\n          1,\n          _instance.entity as any,\n          EntityType.Entity.serializeBinaryToWriter\n        );\n      }\n      if (_instance.errorMessage || _instance.errorMessage === '') {\n        _writer.writeString(2, _instance.errorMessage);\n      }\n    }\n\n    private _entity?: EntityType.Entity;\n    private _errorMessage?: string;\n\n    private _entityOrStatus: EntityStatus.EntityOrStatusCase =\n      EntityStatus.EntityOrStatusCase.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 EntityStatus to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<EntityStatus.AsObject>) {\n      _value = _value || {};\n      this.entity = _value.entity\n        ? new EntityType.Entity(_value.entity)\n        : undefined;\n      this.errorMessage = _value.errorMessage;\n      EntityStatus.refineValues(this);\n    }\n    get entity(): EntityType.Entity | undefined {\n      return this._entity;\n    }\n    set entity(value: EntityType.Entity | undefined) {\n      if (value !== undefined && value !== null) {\n        this._errorMessage = undefined;\n        this._entityOrStatus = EntityStatus.EntityOrStatusCase.entity;\n      }\n      this._entity = value;\n    }\n    get errorMessage(): string | undefined {\n      return this._errorMessage;\n    }\n    set errorMessage(value: string | undefined) {\n      if (value !== undefined && value !== null) {\n        this._entity = undefined;\n        this._entityOrStatus = EntityStatus.EntityOrStatusCase.errorMessage;\n      }\n      this._errorMessage = value;\n    }\n    get entityOrStatus() {\n      return this._entityOrStatus;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      EntityStatus.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(): EntityStatus.AsObject {\n      return {\n        entity: this.entity ? this.entity.toObject() : undefined,\n        errorMessage: this.errorMessage\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    ): EntityStatus.AsProtobufJSON {\n      return {\n        entity: this.entity ? this.entity.toProtobufJSON(options) : null,\n        errorMessage:\n          this.errorMessage === null || this.errorMessage === undefined\n            ? null\n            : this.errorMessage\n      };\n    }\n  }\n  export module EntityStatus {\n    /**\n     * Standard JavaScript object representation for EntityStatus\n     */\n    export interface AsObject {\n      entity?: EntityType.Entity.AsObject;\n      errorMessage?: string;\n    }\n\n    /**\n     * Protobuf JSON representation for EntityStatus\n     */\n    export interface AsProtobufJSON {\n      entity?: EntityType.Entity.AsProtobufJSON | null;\n      errorMessage?: string | null;\n    }\n    export enum EntityOrStatusCase {\n      none = 0,\n      entity = 1,\n      errorMessage = 2\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchCreateEntitiesRequest\n */\nexport class BatchCreateEntitiesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchCreateEntitiesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchCreateEntitiesRequest();\n    BatchCreateEntitiesRequest.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: BatchCreateEntitiesRequest) {\n    _instance.createEntityRequests = _instance.createEntityRequests || [];\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: BatchCreateEntitiesRequest,\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 BatchCreateEntitiesRequest.CreateEntityRequest();\n          _reader.readMessage(\n            messageInitializer1,\n            BatchCreateEntitiesRequest.CreateEntityRequest\n              .deserializeBinaryFromReader\n          );\n          (_instance.createEntityRequests =\n            _instance.createEntityRequests || []).push(messageInitializer1);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchCreateEntitiesRequest.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: BatchCreateEntitiesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (\n      _instance.createEntityRequests &&\n      _instance.createEntityRequests.length\n    ) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.createEntityRequests as any,\n        BatchCreateEntitiesRequest.CreateEntityRequest.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _createEntityRequests?: BatchCreateEntitiesRequest.CreateEntityRequest[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of BatchCreateEntitiesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<BatchCreateEntitiesRequest.AsObject>) {\n    _value = _value || {};\n    this.createEntityRequests = (_value.createEntityRequests || []).map(\n      m => new BatchCreateEntitiesRequest.CreateEntityRequest(m)\n    );\n    BatchCreateEntitiesRequest.refineValues(this);\n  }\n  get createEntityRequests():\n    | BatchCreateEntitiesRequest.CreateEntityRequest[]\n    | undefined {\n    return this._createEntityRequests;\n  }\n  set createEntityRequests(\n    value: BatchCreateEntitiesRequest.CreateEntityRequest[] | undefined\n  ) {\n    this._createEntityRequests = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchCreateEntitiesRequest.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(): BatchCreateEntitiesRequest.AsObject {\n    return {\n      createEntityRequests: (this.createEntityRequests || []).map(m =>\n        m.toObject()\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  ): BatchCreateEntitiesRequest.AsProtobufJSON {\n    return {\n      createEntityRequests: (this.createEntityRequests || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module BatchCreateEntitiesRequest {\n  /**\n   * Standard JavaScript object representation for BatchCreateEntitiesRequest\n   */\n  export interface AsObject {\n    createEntityRequests?: BatchCreateEntitiesRequest.CreateEntityRequest.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for BatchCreateEntitiesRequest\n   */\n  export interface AsProtobufJSON {\n    createEntityRequests?:\n      | BatchCreateEntitiesRequest.CreateEntityRequest.AsProtobufJSON[]\n      | null;\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.CreateEntityRequest\n   */\n  export class CreateEntityRequest implements GrpcMessage {\n    static id = 'ondewo.nlu.CreateEntityRequest';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new CreateEntityRequest();\n      CreateEntityRequest.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: CreateEntityRequest) {\n      _instance.entityTypeName = _instance.entityTypeName || '';\n      _instance.entity = _instance.entity || 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: CreateEntityRequest,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.entityTypeName = _reader.readString();\n            break;\n          case 2:\n            _instance.entity = new EntityType.Entity();\n            _reader.readMessage(\n              _instance.entity,\n              EntityType.Entity.deserializeBinaryFromReader\n            );\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      CreateEntityRequest.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: CreateEntityRequest,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.entityTypeName) {\n        _writer.writeString(1, _instance.entityTypeName);\n      }\n      if (_instance.entity) {\n        _writer.writeMessage(\n          2,\n          _instance.entity as any,\n          EntityType.Entity.serializeBinaryToWriter\n        );\n      }\n    }\n\n    private _entityTypeName?: string;\n    private _entity?: EntityType.Entity;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of CreateEntityRequest to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<CreateEntityRequest.AsObject>) {\n      _value = _value || {};\n      this.entityTypeName = _value.entityTypeName;\n      this.entity = _value.entity\n        ? new EntityType.Entity(_value.entity)\n        : undefined;\n      CreateEntityRequest.refineValues(this);\n    }\n    get entityTypeName(): string | undefined {\n      return this._entityTypeName;\n    }\n    set entityTypeName(value: string | undefined) {\n      this._entityTypeName = value;\n    }\n    get entity(): EntityType.Entity | undefined {\n      return this._entity;\n    }\n    set entity(value: EntityType.Entity | undefined) {\n      this._entity = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      CreateEntityRequest.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(): CreateEntityRequest.AsObject {\n      return {\n        entityTypeName: this.entityTypeName,\n        entity: this.entity ? this.entity.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    ): CreateEntityRequest.AsProtobufJSON {\n      return {\n        entityTypeName: this.entityTypeName,\n        entity: this.entity ? this.entity.toProtobufJSON(options) : null\n      };\n    }\n  }\n  export module CreateEntityRequest {\n    /**\n     * Standard JavaScript object representation for CreateEntityRequest\n     */\n    export interface AsObject {\n      entityTypeName?: string;\n      entity?: EntityType.Entity.AsObject;\n    }\n\n    /**\n     * Protobuf JSON representation for CreateEntityRequest\n     */\n    export interface AsProtobufJSON {\n      entityTypeName?: string;\n      entity?: EntityType.Entity.AsProtobufJSON | null;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchUpdateEntitiesRequest\n */\nexport class BatchUpdateEntitiesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchUpdateEntitiesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchUpdateEntitiesRequest();\n    BatchUpdateEntitiesRequest.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: BatchUpdateEntitiesRequest) {\n    _instance.entities = _instance.entities || [];\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: BatchUpdateEntitiesRequest,\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 EntityType.Entity();\n          _reader.readMessage(\n            messageInitializer1,\n            EntityType.Entity.deserializeBinaryFromReader\n          );\n          (_instance.entities = _instance.entities || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchUpdateEntitiesRequest.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: BatchUpdateEntitiesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entities && _instance.entities.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.entities as any,\n        EntityType.Entity.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _entities?: EntityType.Entity[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of BatchUpdateEntitiesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<BatchUpdateEntitiesRequest.AsObject>) {\n    _value = _value || {};\n    this.entities = (_value.entities || []).map(m => new EntityType.Entity(m));\n    BatchUpdateEntitiesRequest.refineValues(this);\n  }\n  get entities(): EntityType.Entity[] | undefined {\n    return this._entities;\n  }\n  set entities(value: EntityType.Entity[] | undefined) {\n    this._entities = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchUpdateEntitiesRequest.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(): BatchUpdateEntitiesRequest.AsObject {\n    return {\n      entities: (this.entities || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): BatchUpdateEntitiesRequest.AsProtobufJSON {\n    return {\n      entities: (this.entities || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module BatchUpdateEntitiesRequest {\n  /**\n   * Standard JavaScript object representation for BatchUpdateEntitiesRequest\n   */\n  export interface AsObject {\n    entities?: EntityType.Entity.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for BatchUpdateEntitiesRequest\n   */\n  export interface AsProtobufJSON {\n    entities?: EntityType.Entity.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchGetEntitiesRequest\n */\nexport class BatchGetEntitiesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchGetEntitiesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchGetEntitiesRequest();\n    BatchGetEntitiesRequest.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: BatchGetEntitiesRequest) {\n    _instance.names = _instance.names || [];\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: BatchGetEntitiesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.names = _instance.names || []).push(_reader.readString());\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchGetEntitiesRequest.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: BatchGetEntitiesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.names && _instance.names.length) {\n      _writer.writeRepeatedString(1, _instance.names);\n    }\n  }\n\n  private _names?: 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 BatchGetEntitiesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<BatchGetEntitiesRequest.AsObject>) {\n    _value = _value || {};\n    this.names = (_value.names || []).slice();\n    BatchGetEntitiesRequest.refineValues(this);\n  }\n  get names(): string[] | undefined {\n    return this._names;\n  }\n  set names(value: string[] | undefined) {\n    this._names = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchGetEntitiesRequest.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(): BatchGetEntitiesRequest.AsObject {\n    return {\n      names: (this.names || []).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  ): BatchGetEntitiesRequest.AsProtobufJSON {\n    return {\n      names: (this.names || []).slice()\n    };\n  }\n}\nexport module BatchGetEntitiesRequest {\n  /**\n   * Standard JavaScript object representation for BatchGetEntitiesRequest\n   */\n  export interface AsObject {\n    names?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for BatchGetEntitiesRequest\n   */\n  export interface AsProtobufJSON {\n    names?: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchDeleteEntitiesRequest\n */\nexport class BatchDeleteEntitiesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchDeleteEntitiesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchDeleteEntitiesRequest();\n    BatchDeleteEntitiesRequest.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: BatchDeleteEntitiesRequest) {\n    _instance.names = _instance.names || [];\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: BatchDeleteEntitiesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.names = _instance.names || []).push(_reader.readString());\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchDeleteEntitiesRequest.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: BatchDeleteEntitiesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.names && _instance.names.length) {\n      _writer.writeRepeatedString(1, _instance.names);\n    }\n  }\n\n  private _names?: 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 BatchDeleteEntitiesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<BatchDeleteEntitiesRequest.AsObject>) {\n    _value = _value || {};\n    this.names = (_value.names || []).slice();\n    BatchDeleteEntitiesRequest.refineValues(this);\n  }\n  get names(): string[] | undefined {\n    return this._names;\n  }\n  set names(value: string[] | undefined) {\n    this._names = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchDeleteEntitiesRequest.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(): BatchDeleteEntitiesRequest.AsObject {\n    return {\n      names: (this.names || []).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  ): BatchDeleteEntitiesRequest.AsProtobufJSON {\n    return {\n      names: (this.names || []).slice()\n    };\n  }\n}\nexport module BatchDeleteEntitiesRequest {\n  /**\n   * Standard JavaScript object representation for BatchDeleteEntitiesRequest\n   */\n  export interface AsObject {\n    names?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for BatchDeleteEntitiesRequest\n   */\n  export interface AsProtobufJSON {\n    names?: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.BatchDeleteEntitiesResponse\n */\nexport class BatchDeleteEntitiesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.BatchDeleteEntitiesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new BatchDeleteEntitiesResponse();\n    BatchDeleteEntitiesResponse.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: BatchDeleteEntitiesResponse) {\n    _instance.deleteStatuses = _instance.deleteStatuses || [];\n    _instance.hasErrors = _instance.hasErrors || false;\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: BatchDeleteEntitiesResponse,\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 BatchDeleteEntitiesResponse.DeleteEntityStatus();\n          _reader.readMessage(\n            messageInitializer1,\n            BatchDeleteEntitiesResponse.DeleteEntityStatus\n              .deserializeBinaryFromReader\n          );\n          (_instance.deleteStatuses = _instance.deleteStatuses || []).push(\n            messageInitializer1\n          );\n          break;\n        case 2:\n          _instance.hasErrors = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    BatchDeleteEntitiesResponse.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: BatchDeleteEntitiesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.deleteStatuses && _instance.deleteStatuses.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.deleteStatuses as any,\n        BatchDeleteEntitiesResponse.DeleteEntityStatus.serializeBinaryToWriter\n      );\n    }\n    if (_instance.hasErrors) {\n      _writer.writeBool(2, _instance.hasErrors);\n    }\n  }\n\n  private _deleteStatuses?: BatchDeleteEntitiesResponse.DeleteEntityStatus[];\n  private _hasErrors?: boolean;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of BatchDeleteEntitiesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<BatchDeleteEntitiesResponse.AsObject>) {\n    _value = _value || {};\n    this.deleteStatuses = (_value.deleteStatuses || []).map(\n      m => new BatchDeleteEntitiesResponse.DeleteEntityStatus(m)\n    );\n    this.hasErrors = _value.hasErrors;\n    BatchDeleteEntitiesResponse.refineValues(this);\n  }\n  get deleteStatuses():\n    | BatchDeleteEntitiesResponse.DeleteEntityStatus[]\n    | undefined {\n    return this._deleteStatuses;\n  }\n  set deleteStatuses(\n    value: BatchDeleteEntitiesResponse.DeleteEntityStatus[] | undefined\n  ) {\n    this._deleteStatuses = value;\n  }\n  get hasErrors(): boolean | undefined {\n    return this._hasErrors;\n  }\n  set hasErrors(value: boolean | undefined) {\n    this._hasErrors = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    BatchDeleteEntitiesResponse.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(): BatchDeleteEntitiesResponse.AsObject {\n    return {\n      deleteStatuses: (this.deleteStatuses || []).map(m => m.toObject()),\n      hasErrors: this.hasErrors\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  ): BatchDeleteEntitiesResponse.AsProtobufJSON {\n    return {\n      deleteStatuses: (this.deleteStatuses || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      hasErrors: this.hasErrors\n    };\n  }\n}\nexport module BatchDeleteEntitiesResponse {\n  /**\n   * Standard JavaScript object representation for BatchDeleteEntitiesResponse\n   */\n  export interface AsObject {\n    deleteStatuses?: BatchDeleteEntitiesResponse.DeleteEntityStatus.AsObject[];\n    hasErrors?: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for BatchDeleteEntitiesResponse\n   */\n  export interface AsProtobufJSON {\n    deleteStatuses?:\n      | BatchDeleteEntitiesResponse.DeleteEntityStatus.AsProtobufJSON[]\n      | null;\n    hasErrors?: boolean;\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.DeleteEntityStatus\n   */\n  export class DeleteEntityStatus implements GrpcMessage {\n    static id = 'ondewo.nlu.DeleteEntityStatus';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new DeleteEntityStatus();\n      DeleteEntityStatus.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: DeleteEntityStatus) {}\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: DeleteEntityStatus,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.successfullyDeleted = new googleProtobuf004.Empty();\n            _reader.readMessage(\n              _instance.successfullyDeleted,\n              googleProtobuf004.Empty.deserializeBinaryFromReader\n            );\n            break;\n          case 2:\n            _instance.errorMessage = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      DeleteEntityStatus.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: DeleteEntityStatus,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.successfullyDeleted) {\n        _writer.writeMessage(\n          1,\n          _instance.successfullyDeleted as any,\n          googleProtobuf004.Empty.serializeBinaryToWriter\n        );\n      }\n      if (_instance.errorMessage || _instance.errorMessage === '') {\n        _writer.writeString(2, _instance.errorMessage);\n      }\n    }\n\n    private _successfullyDeleted?: googleProtobuf004.Empty;\n    private _errorMessage?: string;\n\n    private _deleteStatus: DeleteEntityStatus.DeleteStatusCase =\n      DeleteEntityStatus.DeleteStatusCase.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 DeleteEntityStatus to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<DeleteEntityStatus.AsObject>) {\n      _value = _value || {};\n      this.successfullyDeleted = _value.successfullyDeleted\n        ? new googleProtobuf004.Empty(_value.successfullyDeleted)\n        : undefined;\n      this.errorMessage = _value.errorMessage;\n      DeleteEntityStatus.refineValues(this);\n    }\n    get successfullyDeleted(): googleProtobuf004.Empty | undefined {\n      return this._successfullyDeleted;\n    }\n    set successfullyDeleted(value: googleProtobuf004.Empty | undefined) {\n      if (value !== undefined && value !== null) {\n        this._errorMessage = undefined;\n        this._deleteStatus =\n          DeleteEntityStatus.DeleteStatusCase.successfullyDeleted;\n      }\n      this._successfullyDeleted = value;\n    }\n    get errorMessage(): string | undefined {\n      return this._errorMessage;\n    }\n    set errorMessage(value: string | undefined) {\n      if (value !== undefined && value !== null) {\n        this._successfullyDeleted = undefined;\n        this._deleteStatus = DeleteEntityStatus.DeleteStatusCase.errorMessage;\n      }\n      this._errorMessage = value;\n    }\n    get deleteStatus() {\n      return this._deleteStatus;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      DeleteEntityStatus.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(): DeleteEntityStatus.AsObject {\n      return {\n        successfullyDeleted: this.successfullyDeleted\n          ? this.successfullyDeleted.toObject()\n          : undefined,\n        errorMessage: this.errorMessage\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    ): DeleteEntityStatus.AsProtobufJSON {\n      return {\n        successfullyDeleted: this.successfullyDeleted\n          ? this.successfullyDeleted.toProtobufJSON(options)\n          : null,\n        errorMessage:\n          this.errorMessage === null || this.errorMessage === undefined\n            ? null\n            : this.errorMessage\n      };\n    }\n  }\n  export module DeleteEntityStatus {\n    /**\n     * Standard JavaScript object representation for DeleteEntityStatus\n     */\n    export interface AsObject {\n      successfullyDeleted?: googleProtobuf004.Empty.AsObject;\n      errorMessage?: string;\n    }\n\n    /**\n     * Protobuf JSON representation for DeleteEntityStatus\n     */\n    export interface AsProtobufJSON {\n      successfullyDeleted?: googleProtobuf004.Empty.AsProtobufJSON | null;\n      errorMessage?: string | null;\n    }\n    export enum DeleteStatusCase {\n      none = 0,\n      successfullyDeleted = 1,\n      errorMessage = 2\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListEntitiesRequest\n */\nexport class ListEntitiesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListEntitiesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListEntitiesRequest();\n    ListEntitiesRequest.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: ListEntitiesRequest) {\n    _instance.entityTypeName = _instance.entityTypeName || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.pageToken = _instance.pageToken || '';\n    _instance.sortByField = _instance.sortByField || undefined;\n    _instance.searchByPattern = _instance.searchByPattern || '';\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: ListEntitiesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.entityTypeName = _reader.readString();\n          break;\n        case 2:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 3:\n          _instance.pageToken = _reader.readString();\n          break;\n        case 5:\n          _instance.sortByField = new EntityValueSorting();\n          _reader.readMessage(\n            _instance.sortByField,\n            EntityValueSorting.deserializeBinaryFromReader\n          );\n          break;\n        case 6:\n          _instance.searchByPattern = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListEntitiesRequest.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: ListEntitiesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityTypeName) {\n      _writer.writeString(1, _instance.entityTypeName);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.pageToken) {\n      _writer.writeString(3, _instance.pageToken);\n    }\n    if (_instance.sortByField) {\n      _writer.writeMessage(\n        5,\n        _instance.sortByField as any,\n        EntityValueSorting.serializeBinaryToWriter\n      );\n    }\n    if (_instance.searchByPattern) {\n      _writer.writeString(6, _instance.searchByPattern);\n    }\n  }\n\n  private _entityTypeName?: string;\n  private _languageCode?: string;\n  private _pageToken?: string;\n  private _sortByField?: EntityValueSorting;\n  private _searchByPattern?: 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 ListEntitiesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListEntitiesRequest.AsObject>) {\n    _value = _value || {};\n    this.entityTypeName = _value.entityTypeName;\n    this.languageCode = _value.languageCode;\n    this.pageToken = _value.pageToken;\n    this.sortByField = _value.sortByField\n      ? new EntityValueSorting(_value.sortByField)\n      : undefined;\n    this.searchByPattern = _value.searchByPattern;\n    ListEntitiesRequest.refineValues(this);\n  }\n  get entityTypeName(): string | undefined {\n    return this._entityTypeName;\n  }\n  set entityTypeName(value: string | undefined) {\n    this._entityTypeName = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get pageToken(): string | undefined {\n    return this._pageToken;\n  }\n  set pageToken(value: string | undefined) {\n    this._pageToken = value;\n  }\n  get sortByField(): EntityValueSorting | undefined {\n    return this._sortByField;\n  }\n  set sortByField(value: EntityValueSorting | undefined) {\n    this._sortByField = value;\n  }\n  get searchByPattern(): string | undefined {\n    return this._searchByPattern;\n  }\n  set searchByPattern(value: string | undefined) {\n    this._searchByPattern = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListEntitiesRequest.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(): ListEntitiesRequest.AsObject {\n    return {\n      entityTypeName: this.entityTypeName,\n      languageCode: this.languageCode,\n      pageToken: this.pageToken,\n      sortByField: this.sortByField ? this.sortByField.toObject() : undefined,\n      searchByPattern: this.searchByPattern\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  ): ListEntitiesRequest.AsProtobufJSON {\n    return {\n      entityTypeName: this.entityTypeName,\n      languageCode: this.languageCode,\n      pageToken: this.pageToken,\n      sortByField: this.sortByField\n        ? this.sortByField.toProtobufJSON(options)\n        : null,\n      searchByPattern: this.searchByPattern\n    };\n  }\n}\nexport module ListEntitiesRequest {\n  /**\n   * Standard JavaScript object representation for ListEntitiesRequest\n   */\n  export interface AsObject {\n    entityTypeName?: string;\n    languageCode?: string;\n    pageToken?: string;\n    sortByField?: EntityValueSorting.AsObject;\n    searchByPattern?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListEntitiesRequest\n   */\n  export interface AsProtobufJSON {\n    entityTypeName?: string;\n    languageCode?: string;\n    pageToken?: string;\n    sortByField?: EntityValueSorting.AsProtobufJSON | null;\n    searchByPattern?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListEntitiesResponse\n */\nexport class ListEntitiesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListEntitiesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListEntitiesResponse();\n    ListEntitiesResponse.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: ListEntitiesResponse) {\n    _instance.entities = _instance.entities || [];\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: ListEntitiesResponse,\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 EntityType.Entity();\n          _reader.readMessage(\n            messageInitializer1,\n            EntityType.Entity.deserializeBinaryFromReader\n          );\n          (_instance.entities = _instance.entities || []).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    ListEntitiesResponse.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: ListEntitiesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entities && _instance.entities.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.entities as any,\n        EntityType.Entity.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _entities?: EntityType.Entity[];\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 ListEntitiesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListEntitiesResponse.AsObject>) {\n    _value = _value || {};\n    this.entities = (_value.entities || []).map(m => new EntityType.Entity(m));\n    this.nextPageToken = _value.nextPageToken;\n    ListEntitiesResponse.refineValues(this);\n  }\n  get entities(): EntityType.Entity[] | undefined {\n    return this._entities;\n  }\n  set entities(value: EntityType.Entity[] | undefined) {\n    this._entities = 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    ListEntitiesResponse.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(): ListEntitiesResponse.AsObject {\n    return {\n      entities: (this.entities || []).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  ): ListEntitiesResponse.AsProtobufJSON {\n    return {\n      entities: (this.entities || []).map(m => m.toProtobufJSON(options)),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListEntitiesResponse {\n  /**\n   * Standard JavaScript object representation for ListEntitiesResponse\n   */\n  export interface AsObject {\n    entities?: EntityType.Entity.AsObject[];\n    nextPageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListEntitiesResponse\n   */\n  export interface AsProtobufJSON {\n    entities?: EntityType.Entity.AsProtobufJSON[] | null;\n    nextPageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.EntityValueSorting\n */\nexport class EntityValueSorting implements GrpcMessage {\n  static id = 'ondewo.nlu.EntityValueSorting';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new EntityValueSorting();\n    EntityValueSorting.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: EntityValueSorting) {\n    _instance.sortingField = _instance.sortingField || 0;\n    _instance.sortingMode = _instance.sortingMode || 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: EntityValueSorting,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 7:\n          _instance.sortingField = _reader.readEnum();\n          break;\n        case 8:\n          _instance.sortingMode = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    EntityValueSorting.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: EntityValueSorting,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.sortingField) {\n      _writer.writeEnum(7, _instance.sortingField);\n    }\n    if (_instance.sortingMode) {\n      _writer.writeEnum(8, _instance.sortingMode);\n    }\n  }\n\n  private _sortingField?: EntityValueSorting.EntityValueSortingField;\n  private _sortingMode?: ondewoNlu009.SortingMode;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of EntityValueSorting to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<EntityValueSorting.AsObject>) {\n    _value = _value || {};\n    this.sortingField = _value.sortingField;\n    this.sortingMode = _value.sortingMode;\n    EntityValueSorting.refineValues(this);\n  }\n  get sortingField(): EntityValueSorting.EntityValueSortingField | undefined {\n    return this._sortingField;\n  }\n  set sortingField(\n    value: EntityValueSorting.EntityValueSortingField | undefined\n  ) {\n    this._sortingField = value;\n  }\n  get sortingMode(): ondewoNlu009.SortingMode | undefined {\n    return this._sortingMode;\n  }\n  set sortingMode(value: ondewoNlu009.SortingMode | undefined) {\n    this._sortingMode = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    EntityValueSorting.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(): EntityValueSorting.AsObject {\n    return {\n      sortingField: this.sortingField,\n      sortingMode: this.sortingMode\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  ): EntityValueSorting.AsProtobufJSON {\n    return {\n      sortingField:\n        EntityValueSorting.EntityValueSortingField[\n          this.sortingField === null || this.sortingField === undefined\n            ? 0\n            : this.sortingField\n        ],\n      sortingMode:\n        ondewoNlu009.SortingMode[\n          this.sortingMode === null || this.sortingMode === undefined\n            ? 0\n            : this.sortingMode\n        ]\n    };\n  }\n}\nexport module EntityValueSorting {\n  /**\n   * Standard JavaScript object representation for EntityValueSorting\n   */\n  export interface AsObject {\n    sortingField?: EntityValueSorting.EntityValueSortingField;\n    sortingMode?: ondewoNlu009.SortingMode;\n  }\n\n  /**\n   * Protobuf JSON representation for EntityValueSorting\n   */\n  export interface AsProtobufJSON {\n    sortingField?: string;\n    sortingMode?: string;\n  }\n  export enum EntityValueSortingField {\n    NO_ENTITY_VALUE_SORTING = 0,\n    SORT_ENTITY_VALUE_BY_DISPLAY_NAME = 1,\n    SORT_ENTITY_VALUE_BY_VALUE = 2,\n    SORT_ENTITY_VALUE_BY_SYNONYM_COUNT = 3\n  }\n}\n"]}