@ondewo/csi-client-angular 3.2.1 → 4.0.0

package/esm2022/api/ondewo/nlu/ccai-project.pb.mjs

@@ -0,0 +1,2490 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf000 from '@ngx-grpc/well-known-types';
+import * as googleProtobuf001 from '@ngx-grpc/well-known-types';
+import * as googleProtobuf002 from '@ngx-grpc/well-known-types';
+import * as ondewoNlu003 from '../../ondewo/nlu/common.pb';
+export var CcaiProjectStatus;
+(function (CcaiProjectStatus) {
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_UNSPECIFIED"] = 0] = "CCAI_PROJECT_STATUS_UNSPECIFIED";
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_UNDEPLOYED"] = 1] = "CCAI_PROJECT_STATUS_UNDEPLOYED";
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_UPDATING"] = 2] = "CCAI_PROJECT_STATUS_UPDATING";
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_DEPLOYING"] = 3] = "CCAI_PROJECT_STATUS_DEPLOYING";
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_DEPLOYED"] = 4] = "CCAI_PROJECT_STATUS_DEPLOYED";
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_UNDEPLOYING"] = 5] = "CCAI_PROJECT_STATUS_UNDEPLOYING";
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_DELETING"] = 6] = "CCAI_PROJECT_STATUS_DELETING";
+    CcaiProjectStatus[CcaiProjectStatus["CCAI_PROJECT_STATUS_DELETED"] = 7] = "CCAI_PROJECT_STATUS_DELETED";
+})(CcaiProjectStatus || (CcaiProjectStatus = {}));
+export var CcaiServiceType;
+(function (CcaiServiceType) {
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_UNSPECIFIED"] = 0] = "CCAI_SERVICE_TYPE_UNSPECIFIED";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_AIM"] = 1] = "CCAI_SERVICE_TYPE_ONDEWO_AIM";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_BPI"] = 2] = "CCAI_SERVICE_TYPE_ONDEWO_BPI";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_CSI"] = 3] = "CCAI_SERVICE_TYPE_ONDEWO_CSI";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_NLU"] = 4] = "CCAI_SERVICE_TYPE_ONDEWO_NLU";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_S2T"] = 5] = "CCAI_SERVICE_TYPE_ONDEWO_S2T";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_SIP"] = 6] = "CCAI_SERVICE_TYPE_ONDEWO_SIP";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_T2S"] = 7] = "CCAI_SERVICE_TYPE_ONDEWO_T2S";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_VTSI"] = 8] = "CCAI_SERVICE_TYPE_ONDEWO_VTSI";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_VTSI_RABBITMQ"] = 9] = "CCAI_SERVICE_TYPE_VTSI_RABBITMQ";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_NLU_QA"] = 10] = "CCAI_SERVICE_TYPE_ONDEWO_NLU_QA";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_NLU_WEBHOOK"] = 11] = "CCAI_SERVICE_TYPE_ONDEWO_NLU_WEBHOOK";
+    CcaiServiceType[CcaiServiceType["CCAI_SERVICE_TYPE_ONDEWO_SURVEY"] = 12] = "CCAI_SERVICE_TYPE_ONDEWO_SURVEY";
+})(CcaiServiceType || (CcaiServiceType = {}));
+export var CcaiProjectView;
+(function (CcaiProjectView) {
+    CcaiProjectView[CcaiProjectView["CCAI_PROJECT_VIEW_UNSPECIFIED"] = 0] = "CCAI_PROJECT_VIEW_UNSPECIFIED";
+    CcaiProjectView[CcaiProjectView["CCAI_PROJECT_VIEW_FULL"] = 1] = "CCAI_PROJECT_VIEW_FULL";
+    CcaiProjectView[CcaiProjectView["CCAI_PROJECT_VIEW_SHALLOW"] = 2] = "CCAI_PROJECT_VIEW_SHALLOW";
+    CcaiProjectView[CcaiProjectView["CCAI_PROJECT_VIEW_MINIMUM"] = 3] = "CCAI_PROJECT_VIEW_MINIMUM";
+})(CcaiProjectView || (CcaiProjectView = {}));
+/**
+ * Message implementation for ondewo.nlu.CcaiProject
+ */
+export class CcaiProject {
+    static { this.id = 'ondewo.nlu.CcaiProject'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CcaiProject();
+        CcaiProject.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.ownerName = _instance.ownerName || '';
+        _instance.ccaiServicesMap = _instance.ccaiServicesMap || {};
+        _instance.ccaiProjectStatus = _instance.ccaiProjectStatus || 0;
+        _instance.createdAt = _instance.createdAt || undefined;
+        _instance.modifiedAt = _instance.modifiedAt || undefined;
+        _instance.createdBy = _instance.createdBy || '';
+        _instance.modifiedBy = _instance.modifiedBy || '';
+        _instance.nluProjectName = _instance.nluProjectName || '';
+    }
+    /**
+     * 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.ownerName = _reader.readString();
+                    break;
+                case 4:
+                    const msg_4 = {};
+                    _reader.readMessage(msg_4, CcaiProject.CcaiServicesMapEntry.deserializeBinaryFromReader);
+                    _instance.ccaiServicesMap = _instance.ccaiServicesMap || {};
+                    _instance.ccaiServicesMap[msg_4.key] = msg_4.value;
+                    break;
+                case 5:
+                    _instance.ccaiProjectStatus = _reader.readEnum();
+                    break;
+                case 6:
+                    _instance.createdAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.modifiedAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.modifiedAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 8:
+                    _instance.createdBy = _reader.readString();
+                    break;
+                case 9:
+                    _instance.modifiedBy = _reader.readString();
+                    break;
+                case 10:
+                    _instance.nluProjectName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CcaiProject.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.ownerName) {
+            _writer.writeString(3, _instance.ownerName);
+        }
+        if (!!_instance.ccaiServicesMap) {
+            const keys_4 = Object.keys(_instance.ccaiServicesMap);
+            if (keys_4.length) {
+                const repeated_4 = keys_4
+                    .map(key => ({
+                    key: key,
+                    value: _instance.ccaiServicesMap[key]
+                }))
+                    .reduce((r, v) => [...r, v], []);
+                _writer.writeRepeatedMessage(4, repeated_4, CcaiProject.CcaiServicesMapEntry.serializeBinaryToWriter);
+            }
+        }
+        if (_instance.ccaiProjectStatus) {
+            _writer.writeEnum(5, _instance.ccaiProjectStatus);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(6, _instance.createdAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.modifiedAt) {
+            _writer.writeMessage(7, _instance.modifiedAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.createdBy) {
+            _writer.writeString(8, _instance.createdBy);
+        }
+        if (_instance.modifiedBy) {
+            _writer.writeString(9, _instance.modifiedBy);
+        }
+        if (_instance.nluProjectName) {
+            _writer.writeString(10, _instance.nluProjectName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CcaiProject to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.displayName = _value.displayName;
+        this.ownerName = _value.ownerName;
+        (this.ccaiServicesMap = _value.ccaiServicesMap
+            ? Object.keys(_value.ccaiServicesMap).reduce((r, k) => ({
+                ...r,
+                [k]: _value.ccaiServicesMap[k]
+                    ? new CcaiServiceList(_value.ccaiServicesMap[k])
+                    : undefined
+            }), {})
+            : {}),
+            (this.ccaiProjectStatus = _value.ccaiProjectStatus);
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf001.Timestamp(_value.createdAt)
+            : undefined;
+        this.modifiedAt = _value.modifiedAt
+            ? new googleProtobuf001.Timestamp(_value.modifiedAt)
+            : undefined;
+        this.createdBy = _value.createdBy;
+        this.modifiedBy = _value.modifiedBy;
+        this.nluProjectName = _value.nluProjectName;
+        CcaiProject.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    set displayName(value) {
+        this._displayName = value;
+    }
+    get ownerName() {
+        return this._ownerName;
+    }
+    set ownerName(value) {
+        this._ownerName = value;
+    }
+    get ccaiServicesMap() {
+        return this._ccaiServicesMap;
+    }
+    set ccaiServicesMap(value) {
+        this._ccaiServicesMap = value;
+    }
+    get ccaiProjectStatus() {
+        return this._ccaiProjectStatus;
+    }
+    set ccaiProjectStatus(value) {
+        this._ccaiProjectStatus = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get modifiedAt() {
+        return this._modifiedAt;
+    }
+    set modifiedAt(value) {
+        this._modifiedAt = value;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    set createdBy(value) {
+        this._createdBy = value;
+    }
+    get modifiedBy() {
+        return this._modifiedBy;
+    }
+    set modifiedBy(value) {
+        this._modifiedBy = value;
+    }
+    get nluProjectName() {
+        return this._nluProjectName;
+    }
+    set nluProjectName(value) {
+        this._nluProjectName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CcaiProject.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,
+            ownerName: this.ownerName,
+            ccaiServicesMap: this.ccaiServicesMap
+                ? Object.keys(this.ccaiServicesMap).reduce((r, k) => ({
+                    ...r,
+                    [k]: this.ccaiServicesMap[k]
+                        ? this.ccaiServicesMap[k].toObject()
+                        : undefined
+                }), {})
+                : {},
+            ccaiProjectStatus: this.ccaiProjectStatus,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined,
+            modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy,
+            nluProjectName: this.nluProjectName
+        };
+    }
+    /**
+     * 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,
+            ownerName: this.ownerName,
+            ccaiServicesMap: this.ccaiServicesMap
+                ? Object.keys(this.ccaiServicesMap).reduce((r, k) => ({
+                    ...r,
+                    [k]: this.ccaiServicesMap[k]
+                        ? this.ccaiServicesMap[k].toJSON()
+                        : null
+                }), {})
+                : {},
+            ccaiProjectStatus: CcaiProjectStatus[this.ccaiProjectStatus === null ||
+                this.ccaiProjectStatus === undefined
+                ? 0
+                : this.ccaiProjectStatus],
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,
+            modifiedAt: this.modifiedAt
+                ? this.modifiedAt.toProtobufJSON(options)
+                : null,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy,
+            nluProjectName: this.nluProjectName
+        };
+    }
+}
+(function (CcaiProject) {
+    /**
+     * Message implementation for ondewo.nlu.CcaiProject.CcaiServicesMapEntry
+     */
+    class CcaiServicesMapEntry {
+        static { this.id = 'ondewo.nlu.CcaiProject.CcaiServicesMapEntry'; }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new CcaiServicesMapEntry();
+            CcaiServicesMapEntry.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.key = _instance.key || '';
+            _instance.value = _instance.value || undefined;
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.key = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.value = new CcaiServiceList();
+                        _reader.readMessage(_instance.value, CcaiServiceList.deserializeBinaryFromReader);
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            CcaiServicesMapEntry.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.key) {
+                _writer.writeString(1, _instance.key);
+            }
+            if (_instance.value) {
+                _writer.writeMessage(2, _instance.value, CcaiServiceList.serializeBinaryToWriter);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of CcaiServicesMapEntry to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.key = _value.key;
+            this.value = _value.value ? new CcaiServiceList(_value.value) : undefined;
+            CcaiServicesMapEntry.refineValues(this);
+        }
+        get key() {
+            return this._key;
+        }
+        set key(value) {
+            this._key = value;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            CcaiServicesMapEntry.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                key: this.key,
+                value: this.value ? this.value.toObject() : undefined
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                key: this.key,
+                value: this.value ? this.value.toProtobufJSON(options) : null
+            };
+        }
+    }
+    CcaiProject.CcaiServicesMapEntry = CcaiServicesMapEntry;
+})(CcaiProject || (CcaiProject = {}));
+/**
+ * Message implementation for ondewo.nlu.CcaiServiceList
+ */
+export class CcaiServiceList {
+    static { this.id = 'ondewo.nlu.CcaiServiceList'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CcaiServiceList();
+        CcaiServiceList.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.ccaiServices = _instance.ccaiServices || [];
+    }
+    /**
+     * 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 CcaiService();
+                    _reader.readMessage(messageInitializer1, CcaiService.deserializeBinaryFromReader);
+                    (_instance.ccaiServices = _instance.ccaiServices || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CcaiServiceList.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.ccaiServices && _instance.ccaiServices.length) {
+            _writer.writeRepeatedMessage(1, _instance.ccaiServices, CcaiService.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CcaiServiceList to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.ccaiServices = (_value.ccaiServices || []).map(m => new CcaiService(m));
+        CcaiServiceList.refineValues(this);
+    }
+    get ccaiServices() {
+        return this._ccaiServices;
+    }
+    set ccaiServices(value) {
+        this._ccaiServices = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CcaiServiceList.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            ccaiServices: (this.ccaiServices || []).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 {
+            ccaiServices: (this.ccaiServices || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.CcaiService
+ */
+export class CcaiService {
+    static { this.id = 'ondewo.nlu.CcaiService'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CcaiService();
+        CcaiService.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.languageCode = _instance.languageCode || '';
+        _instance.grpcHost = _instance.grpcHost || '';
+        _instance.grpcPort = _instance.grpcPort || 0;
+        _instance.webgrpcHost = _instance.webgrpcHost || '';
+        _instance.webgrpcPort = _instance.webgrpcPort || 0;
+        _instance.grpcCert = _instance.grpcCert || '';
+        _instance.host = _instance.host || '';
+        _instance.port = _instance.port || 0;
+        _instance.port2 = _instance.port2 || 0;
+        _instance.httpBasicAuthToken = _instance.httpBasicAuthToken || '';
+        _instance.accountName = _instance.accountName || '';
+        _instance.accountPassword = _instance.accountPassword || '';
+        _instance.apiKey = _instance.apiKey || '';
+        _instance.ccaiServiceType = _instance.ccaiServiceType || 0;
+        _instance.ccaiProjectName = _instance.ccaiProjectName || '';
+        _instance.ccaiServiceConfig = _instance.ccaiServiceConfig || undefined;
+        _instance.createdAt = _instance.createdAt || undefined;
+        _instance.modifiedAt = _instance.modifiedAt || undefined;
+        _instance.createdBy = _instance.createdBy || '';
+        _instance.modifiedBy = _instance.modifiedBy || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.name = _reader.readString();
+                    break;
+                case 2:
+                    _instance.displayName = _reader.readString();
+                    break;
+                case 3:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 4:
+                    _instance.grpcHost = _reader.readString();
+                    break;
+                case 5:
+                    _instance.grpcPort = _reader.readInt32();
+                    break;
+                case 6:
+                    _instance.webgrpcHost = _reader.readString();
+                    break;
+                case 7:
+                    _instance.webgrpcPort = _reader.readInt32();
+                    break;
+                case 8:
+                    _instance.grpcCert = _reader.readString();
+                    break;
+                case 9:
+                    _instance.host = _reader.readString();
+                    break;
+                case 10:
+                    _instance.port = _reader.readInt32();
+                    break;
+                case 11:
+                    _instance.port2 = _reader.readInt32();
+                    break;
+                case 12:
+                    _instance.httpBasicAuthToken = _reader.readString();
+                    break;
+                case 13:
+                    _instance.accountName = _reader.readString();
+                    break;
+                case 14:
+                    _instance.accountPassword = _reader.readString();
+                    break;
+                case 15:
+                    _instance.apiKey = _reader.readString();
+                    break;
+                case 16:
+                    _instance.ccaiServiceType = _reader.readEnum();
+                    break;
+                case 17:
+                    _instance.ccaiProjectName = _reader.readString();
+                    break;
+                case 18:
+                    _instance.ccaiServiceConfig = new googleProtobuf002.Struct();
+                    _reader.readMessage(_instance.ccaiServiceConfig, googleProtobuf002.Struct.deserializeBinaryFromReader);
+                    break;
+                case 19:
+                    _instance.createdAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 20:
+                    _instance.modifiedAt = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.modifiedAt, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 21:
+                    _instance.createdBy = _reader.readString();
+                    break;
+                case 22:
+                    _instance.modifiedBy = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CcaiService.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.languageCode) {
+            _writer.writeString(3, _instance.languageCode);
+        }
+        if (_instance.grpcHost) {
+            _writer.writeString(4, _instance.grpcHost);
+        }
+        if (_instance.grpcPort) {
+            _writer.writeInt32(5, _instance.grpcPort);
+        }
+        if (_instance.webgrpcHost) {
+            _writer.writeString(6, _instance.webgrpcHost);
+        }
+        if (_instance.webgrpcPort) {
+            _writer.writeInt32(7, _instance.webgrpcPort);
+        }
+        if (_instance.grpcCert) {
+            _writer.writeString(8, _instance.grpcCert);
+        }
+        if (_instance.host) {
+            _writer.writeString(9, _instance.host);
+        }
+        if (_instance.port) {
+            _writer.writeInt32(10, _instance.port);
+        }
+        if (_instance.port2) {
+            _writer.writeInt32(11, _instance.port2);
+        }
+        if (_instance.httpBasicAuthToken) {
+            _writer.writeString(12, _instance.httpBasicAuthToken);
+        }
+        if (_instance.accountName) {
+            _writer.writeString(13, _instance.accountName);
+        }
+        if (_instance.accountPassword) {
+            _writer.writeString(14, _instance.accountPassword);
+        }
+        if (_instance.apiKey) {
+            _writer.writeString(15, _instance.apiKey);
+        }
+        if (_instance.ccaiServiceType) {
+            _writer.writeEnum(16, _instance.ccaiServiceType);
+        }
+        if (_instance.ccaiProjectName) {
+            _writer.writeString(17, _instance.ccaiProjectName);
+        }
+        if (_instance.ccaiServiceConfig) {
+            _writer.writeMessage(18, _instance.ccaiServiceConfig, googleProtobuf002.Struct.serializeBinaryToWriter);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(19, _instance.createdAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.modifiedAt) {
+            _writer.writeMessage(20, _instance.modifiedAt, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.createdBy) {
+            _writer.writeString(21, _instance.createdBy);
+        }
+        if (_instance.modifiedBy) {
+            _writer.writeString(22, _instance.modifiedBy);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CcaiService to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.displayName = _value.displayName;
+        this.languageCode = _value.languageCode;
+        this.grpcHost = _value.grpcHost;
+        this.grpcPort = _value.grpcPort;
+        this.webgrpcHost = _value.webgrpcHost;
+        this.webgrpcPort = _value.webgrpcPort;
+        this.grpcCert = _value.grpcCert;
+        this.host = _value.host;
+        this.port = _value.port;
+        this.port2 = _value.port2;
+        this.httpBasicAuthToken = _value.httpBasicAuthToken;
+        this.accountName = _value.accountName;
+        this.accountPassword = _value.accountPassword;
+        this.apiKey = _value.apiKey;
+        this.ccaiServiceType = _value.ccaiServiceType;
+        this.ccaiProjectName = _value.ccaiProjectName;
+        this.ccaiServiceConfig = _value.ccaiServiceConfig
+            ? new googleProtobuf002.Struct(_value.ccaiServiceConfig)
+            : undefined;
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf001.Timestamp(_value.createdAt)
+            : undefined;
+        this.modifiedAt = _value.modifiedAt
+            ? new googleProtobuf001.Timestamp(_value.modifiedAt)
+            : undefined;
+        this.createdBy = _value.createdBy;
+        this.modifiedBy = _value.modifiedBy;
+        CcaiService.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    set displayName(value) {
+        this._displayName = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get grpcHost() {
+        return this._grpcHost;
+    }
+    set grpcHost(value) {
+        this._grpcHost = value;
+    }
+    get grpcPort() {
+        return this._grpcPort;
+    }
+    set grpcPort(value) {
+        this._grpcPort = value;
+    }
+    get webgrpcHost() {
+        return this._webgrpcHost;
+    }
+    set webgrpcHost(value) {
+        this._webgrpcHost = value;
+    }
+    get webgrpcPort() {
+        return this._webgrpcPort;
+    }
+    set webgrpcPort(value) {
+        this._webgrpcPort = value;
+    }
+    get grpcCert() {
+        return this._grpcCert;
+    }
+    set grpcCert(value) {
+        this._grpcCert = value;
+    }
+    get host() {
+        return this._host;
+    }
+    set host(value) {
+        this._host = value;
+    }
+    get port() {
+        return this._port;
+    }
+    set port(value) {
+        this._port = value;
+    }
+    get port2() {
+        return this._port2;
+    }
+    set port2(value) {
+        this._port2 = value;
+    }
+    get httpBasicAuthToken() {
+        return this._httpBasicAuthToken;
+    }
+    set httpBasicAuthToken(value) {
+        this._httpBasicAuthToken = value;
+    }
+    get accountName() {
+        return this._accountName;
+    }
+    set accountName(value) {
+        this._accountName = value;
+    }
+    get accountPassword() {
+        return this._accountPassword;
+    }
+    set accountPassword(value) {
+        this._accountPassword = value;
+    }
+    get apiKey() {
+        return this._apiKey;
+    }
+    set apiKey(value) {
+        this._apiKey = value;
+    }
+    get ccaiServiceType() {
+        return this._ccaiServiceType;
+    }
+    set ccaiServiceType(value) {
+        this._ccaiServiceType = value;
+    }
+    get ccaiProjectName() {
+        return this._ccaiProjectName;
+    }
+    set ccaiProjectName(value) {
+        this._ccaiProjectName = value;
+    }
+    get ccaiServiceConfig() {
+        return this._ccaiServiceConfig;
+    }
+    set ccaiServiceConfig(value) {
+        this._ccaiServiceConfig = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get modifiedAt() {
+        return this._modifiedAt;
+    }
+    set modifiedAt(value) {
+        this._modifiedAt = value;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    set createdBy(value) {
+        this._createdBy = value;
+    }
+    get modifiedBy() {
+        return this._modifiedBy;
+    }
+    set modifiedBy(value) {
+        this._modifiedBy = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CcaiService.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,
+            languageCode: this.languageCode,
+            grpcHost: this.grpcHost,
+            grpcPort: this.grpcPort,
+            webgrpcHost: this.webgrpcHost,
+            webgrpcPort: this.webgrpcPort,
+            grpcCert: this.grpcCert,
+            host: this.host,
+            port: this.port,
+            port2: this.port2,
+            httpBasicAuthToken: this.httpBasicAuthToken,
+            accountName: this.accountName,
+            accountPassword: this.accountPassword,
+            apiKey: this.apiKey,
+            ccaiServiceType: this.ccaiServiceType,
+            ccaiProjectName: this.ccaiProjectName,
+            ccaiServiceConfig: this.ccaiServiceConfig
+                ? this.ccaiServiceConfig.toObject()
+                : undefined,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined,
+            modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            languageCode: this.languageCode,
+            grpcHost: this.grpcHost,
+            grpcPort: this.grpcPort,
+            webgrpcHost: this.webgrpcHost,
+            webgrpcPort: this.webgrpcPort,
+            grpcCert: this.grpcCert,
+            host: this.host,
+            port: this.port,
+            port2: this.port2,
+            httpBasicAuthToken: this.httpBasicAuthToken,
+            accountName: this.accountName,
+            accountPassword: this.accountPassword,
+            apiKey: this.apiKey,
+            ccaiServiceType: CcaiServiceType[this.ccaiServiceType === null || this.ccaiServiceType === undefined
+                ? 0
+                : this.ccaiServiceType],
+            ccaiProjectName: this.ccaiProjectName,
+            ccaiServiceConfig: this.ccaiServiceConfig
+                ? this.ccaiServiceConfig.toProtobufJSON(options)
+                : null,
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,
+            modifiedAt: this.modifiedAt
+                ? this.modifiedAt.toProtobufJSON(options)
+                : null,
+            createdBy: this.createdBy,
+            modifiedBy: this.modifiedBy
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.CreateCcaiProjectRequest
+ */
+export class CreateCcaiProjectRequest {
+    static { this.id = 'ondewo.nlu.CreateCcaiProjectRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CreateCcaiProjectRequest();
+        CreateCcaiProjectRequest.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.ccaiProject = _instance.ccaiProject || undefined;
+        _instance.nluProjectName = _instance.nluProjectName || '';
+    }
+    /**
+     * 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.ccaiProject = new CcaiProject();
+                    _reader.readMessage(_instance.ccaiProject, CcaiProject.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.nluProjectName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CreateCcaiProjectRequest.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.ccaiProject) {
+            _writer.writeMessage(1, _instance.ccaiProject, CcaiProject.serializeBinaryToWriter);
+        }
+        if (_instance.nluProjectName) {
+            _writer.writeString(4, _instance.nluProjectName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CreateCcaiProjectRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.ccaiProject = _value.ccaiProject
+            ? new CcaiProject(_value.ccaiProject)
+            : undefined;
+        this.nluProjectName = _value.nluProjectName;
+        CreateCcaiProjectRequest.refineValues(this);
+    }
+    get ccaiProject() {
+        return this._ccaiProject;
+    }
+    set ccaiProject(value) {
+        this._ccaiProject = value;
+    }
+    get nluProjectName() {
+        return this._nluProjectName;
+    }
+    set nluProjectName(value) {
+        this._nluProjectName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CreateCcaiProjectRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            ccaiProject: this.ccaiProject ? this.ccaiProject.toObject() : undefined,
+            nluProjectName: this.nluProjectName
+        };
+    }
+    /**
+     * 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 {
+            ccaiProject: this.ccaiProject
+                ? this.ccaiProject.toProtobufJSON(options)
+                : null,
+            nluProjectName: this.nluProjectName
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.CreateCcaiProjectResponse
+ */
+export class CreateCcaiProjectResponse {
+    static { this.id = 'ondewo.nlu.CreateCcaiProjectResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CreateCcaiProjectResponse();
+        CreateCcaiProjectResponse.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.ccaiProject = _instance.ccaiProject || undefined;
+        _instance.errorMessage = _instance.errorMessage || '';
+    }
+    /**
+     * 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.ccaiProject = new CcaiProject();
+                    _reader.readMessage(_instance.ccaiProject, CcaiProject.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.errorMessage = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CreateCcaiProjectResponse.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.ccaiProject) {
+            _writer.writeMessage(1, _instance.ccaiProject, CcaiProject.serializeBinaryToWriter);
+        }
+        if (_instance.errorMessage) {
+            _writer.writeString(2, _instance.errorMessage);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CreateCcaiProjectResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.ccaiProject = _value.ccaiProject
+            ? new CcaiProject(_value.ccaiProject)
+            : undefined;
+        this.errorMessage = _value.errorMessage;
+        CreateCcaiProjectResponse.refineValues(this);
+    }
+    get ccaiProject() {
+        return this._ccaiProject;
+    }
+    set ccaiProject(value) {
+        this._ccaiProject = value;
+    }
+    get errorMessage() {
+        return this._errorMessage;
+    }
+    set errorMessage(value) {
+        this._errorMessage = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CreateCcaiProjectResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            ccaiProject: this.ccaiProject ? this.ccaiProject.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 {
+            ccaiProject: this.ccaiProject
+                ? this.ccaiProject.toProtobufJSON(options)
+                : null,
+            errorMessage: this.errorMessage
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.GetCcaiProjectRequest
+ */
+export class GetCcaiProjectRequest {
+    static { this.id = 'ondewo.nlu.GetCcaiProjectRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetCcaiProjectRequest();
+        GetCcaiProjectRequest.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.ccaiProjectView = _instance.ccaiProjectView || 0;
+        _instance.ccaiServiceFilter = _instance.ccaiServiceFilter || undefined;
+        _instance.nluProjectName = _instance.nluProjectName || '';
+    }
+    /**
+     * 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.ccaiProjectView = _reader.readEnum();
+                    break;
+                case 3:
+                    _instance.ccaiServiceFilter = new CcaiServiceFilter();
+                    _reader.readMessage(_instance.ccaiServiceFilter, CcaiServiceFilter.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.nluProjectName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetCcaiProjectRequest.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.ccaiProjectView) {
+            _writer.writeEnum(2, _instance.ccaiProjectView);
+        }
+        if (_instance.ccaiServiceFilter) {
+            _writer.writeMessage(3, _instance.ccaiServiceFilter, CcaiServiceFilter.serializeBinaryToWriter);
+        }
+        if (_instance.nluProjectName) {
+            _writer.writeString(4, _instance.nluProjectName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetCcaiProjectRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.ccaiProjectView = _value.ccaiProjectView;
+        this.ccaiServiceFilter = _value.ccaiServiceFilter
+            ? new CcaiServiceFilter(_value.ccaiServiceFilter)
+            : undefined;
+        this.nluProjectName = _value.nluProjectName;
+        GetCcaiProjectRequest.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get ccaiProjectView() {
+        return this._ccaiProjectView;
+    }
+    set ccaiProjectView(value) {
+        this._ccaiProjectView = value;
+    }
+    get ccaiServiceFilter() {
+        return this._ccaiServiceFilter;
+    }
+    set ccaiServiceFilter(value) {
+        this._ccaiServiceFilter = value;
+    }
+    get nluProjectName() {
+        return this._nluProjectName;
+    }
+    set nluProjectName(value) {
+        this._nluProjectName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetCcaiProjectRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            ccaiProjectView: this.ccaiProjectView,
+            ccaiServiceFilter: this.ccaiServiceFilter
+                ? this.ccaiServiceFilter.toObject()
+                : undefined,
+            nluProjectName: this.nluProjectName
+        };
+    }
+    /**
+     * 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,
+            ccaiProjectView: CcaiProjectView[this.ccaiProjectView === null || this.ccaiProjectView === undefined
+                ? 0
+                : this.ccaiProjectView],
+            ccaiServiceFilter: this.ccaiServiceFilter
+                ? this.ccaiServiceFilter.toProtobufJSON(options)
+                : null,
+            nluProjectName: this.nluProjectName
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.ListCcaiProjectsRequest
+ */
+export class ListCcaiProjectsRequest {
+    static { this.id = 'ondewo.nlu.ListCcaiProjectsRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListCcaiProjectsRequest();
+        ListCcaiProjectsRequest.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.ccaiProjectView = _instance.ccaiProjectView || 0;
+        _instance.ccaiServiceFilter = _instance.ccaiServiceFilter || undefined;
+        _instance.ccaiProjectSorting = _instance.ccaiProjectSorting || undefined;
+        _instance.pageToken = _instance.pageToken || '';
+        _instance.nluProjectName = _instance.nluProjectName || '';
+    }
+    /**
+     * 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.ccaiProjectView = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.ccaiServiceFilter = new CcaiServiceFilter();
+                    _reader.readMessage(_instance.ccaiServiceFilter, CcaiServiceFilter.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.ccaiProjectSorting = new CcaiProjectSorting();
+                    _reader.readMessage(_instance.ccaiProjectSorting, CcaiProjectSorting.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.pageToken = _reader.readString();
+                    break;
+                case 5:
+                    _instance.nluProjectName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListCcaiProjectsRequest.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.ccaiProjectView) {
+            _writer.writeEnum(1, _instance.ccaiProjectView);
+        }
+        if (_instance.ccaiServiceFilter) {
+            _writer.writeMessage(2, _instance.ccaiServiceFilter, CcaiServiceFilter.serializeBinaryToWriter);
+        }
+        if (_instance.ccaiProjectSorting) {
+            _writer.writeMessage(3, _instance.ccaiProjectSorting, CcaiProjectSorting.serializeBinaryToWriter);
+        }
+        if (_instance.pageToken) {
+            _writer.writeString(4, _instance.pageToken);
+        }
+        if (_instance.nluProjectName) {
+            _writer.writeString(5, _instance.nluProjectName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListCcaiProjectsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.ccaiProjectView = _value.ccaiProjectView;
+        this.ccaiServiceFilter = _value.ccaiServiceFilter
+            ? new CcaiServiceFilter(_value.ccaiServiceFilter)
+            : undefined;
+        this.ccaiProjectSorting = _value.ccaiProjectSorting
+            ? new CcaiProjectSorting(_value.ccaiProjectSorting)
+            : undefined;
+        this.pageToken = _value.pageToken;
+        this.nluProjectName = _value.nluProjectName;
+        ListCcaiProjectsRequest.refineValues(this);
+    }
+    get ccaiProjectView() {
+        return this._ccaiProjectView;
+    }
+    set ccaiProjectView(value) {
+        this._ccaiProjectView = value;
+    }
+    get ccaiServiceFilter() {
+        return this._ccaiServiceFilter;
+    }
+    set ccaiServiceFilter(value) {
+        this._ccaiServiceFilter = value;
+    }
+    get ccaiProjectSorting() {
+        return this._ccaiProjectSorting;
+    }
+    set ccaiProjectSorting(value) {
+        this._ccaiProjectSorting = value;
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    get nluProjectName() {
+        return this._nluProjectName;
+    }
+    set nluProjectName(value) {
+        this._nluProjectName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListCcaiProjectsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            ccaiProjectView: this.ccaiProjectView,
+            ccaiServiceFilter: this.ccaiServiceFilter
+                ? this.ccaiServiceFilter.toObject()
+                : undefined,
+            ccaiProjectSorting: this.ccaiProjectSorting
+                ? this.ccaiProjectSorting.toObject()
+                : undefined,
+            pageToken: this.pageToken,
+            nluProjectName: this.nluProjectName
+        };
+    }
+    /**
+     * 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 {
+            ccaiProjectView: CcaiProjectView[this.ccaiProjectView === null || this.ccaiProjectView === undefined
+                ? 0
+                : this.ccaiProjectView],
+            ccaiServiceFilter: this.ccaiServiceFilter
+                ? this.ccaiServiceFilter.toProtobufJSON(options)
+                : null,
+            ccaiProjectSorting: this.ccaiProjectSorting
+                ? this.ccaiProjectSorting.toProtobufJSON(options)
+                : null,
+            pageToken: this.pageToken,
+            nluProjectName: this.nluProjectName
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.ListCcaiProjectsResponse
+ */
+export class ListCcaiProjectsResponse {
+    static { this.id = 'ondewo.nlu.ListCcaiProjectsResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListCcaiProjectsResponse();
+        ListCcaiProjectsResponse.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.ccaiProjects = _instance.ccaiProjects || [];
+        _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 CcaiProject();
+                    _reader.readMessage(messageInitializer1, CcaiProject.deserializeBinaryFromReader);
+                    (_instance.ccaiProjects = _instance.ccaiProjects || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListCcaiProjectsResponse.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.ccaiProjects && _instance.ccaiProjects.length) {
+            _writer.writeRepeatedMessage(1, _instance.ccaiProjects, CcaiProject.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListCcaiProjectsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.ccaiProjects = (_value.ccaiProjects || []).map(m => new CcaiProject(m));
+        this.nextPageToken = _value.nextPageToken;
+        ListCcaiProjectsResponse.refineValues(this);
+    }
+    get ccaiProjects() {
+        return this._ccaiProjects;
+    }
+    set ccaiProjects(value) {
+        this._ccaiProjects = 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();
+        ListCcaiProjectsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            ccaiProjects: (this.ccaiProjects || []).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 {
+            ccaiProjects: (this.ccaiProjects || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.CcaiProjectSorting
+ */
+export class CcaiProjectSorting {
+    static { this.id = 'ondewo.nlu.CcaiProjectSorting'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CcaiProjectSorting();
+        CcaiProjectSorting.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();
+            }
+        }
+        CcaiProjectSorting.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);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CcaiProjectSorting to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.sortingField = _value.sortingField;
+        this.sortingMode = _value.sortingMode;
+        CcaiProjectSorting.refineValues(this);
+    }
+    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();
+        CcaiProjectSorting.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: CcaiProjectSorting.CcaiProjectSortingField[this.sortingField === null || this.sortingField === undefined
+                ? 0
+                : this.sortingField],
+            sortingMode: ondewoNlu003.SortingMode[this.sortingMode === null || this.sortingMode === undefined
+                ? 0
+                : this.sortingMode]
+        };
+    }
+}
+(function (CcaiProjectSorting) {
+    let CcaiProjectSortingField;
+    (function (CcaiProjectSortingField) {
+        CcaiProjectSortingField[CcaiProjectSortingField["NO_CCAI_PROJECT_SORTING"] = 0] = "NO_CCAI_PROJECT_SORTING";
+        CcaiProjectSortingField[CcaiProjectSortingField["SORT_CCAI_PROJECT_BY_NAME"] = 1] = "SORT_CCAI_PROJECT_BY_NAME";
+        CcaiProjectSortingField[CcaiProjectSortingField["SORT_CCAI_PROJECT_BY_DISPLAY_NAME"] = 2] = "SORT_CCAI_PROJECT_BY_DISPLAY_NAME";
+        CcaiProjectSortingField[CcaiProjectSortingField["SORT_CCAI_PROJECT_BY_CREATION_DATE"] = 3] = "SORT_CCAI_PROJECT_BY_CREATION_DATE";
+        CcaiProjectSortingField[CcaiProjectSortingField["SORT_CCAI_PROJECT_BY_LAST_MODIFIED"] = 4] = "SORT_CCAI_PROJECT_BY_LAST_MODIFIED";
+    })(CcaiProjectSortingField = CcaiProjectSorting.CcaiProjectSortingField || (CcaiProjectSorting.CcaiProjectSortingField = {}));
+})(CcaiProjectSorting || (CcaiProjectSorting = {}));
+/**
+ * Message implementation for ondewo.nlu.CcaiServiceFilter
+ */
+export class CcaiServiceFilter {
+    static { this.id = 'ondewo.nlu.CcaiServiceFilter'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CcaiServiceFilter();
+        CcaiServiceFilter.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.languageCodes = _instance.languageCodes || [];
+        _instance.ccaiServiceTypes = _instance.ccaiServiceTypes || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    (_instance.languageCodes = _instance.languageCodes || []).push(_reader.readString());
+                    break;
+                case 2:
+                    (_instance.ccaiServiceTypes = _instance.ccaiServiceTypes || []).push(...(_reader.readPackedEnum() || []));
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CcaiServiceFilter.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.languageCodes && _instance.languageCodes.length) {
+            _writer.writeRepeatedString(1, _instance.languageCodes);
+        }
+        if (_instance.ccaiServiceTypes && _instance.ccaiServiceTypes.length) {
+            _writer.writePackedEnum(2, _instance.ccaiServiceTypes);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CcaiServiceFilter to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.languageCodes = (_value.languageCodes || []).slice();
+        this.ccaiServiceTypes = (_value.ccaiServiceTypes || []).slice();
+        CcaiServiceFilter.refineValues(this);
+    }
+    get languageCodes() {
+        return this._languageCodes;
+    }
+    set languageCodes(value) {
+        this._languageCodes = value;
+    }
+    get ccaiServiceTypes() {
+        return this._ccaiServiceTypes;
+    }
+    set ccaiServiceTypes(value) {
+        this._ccaiServiceTypes = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CcaiServiceFilter.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            languageCodes: (this.languageCodes || []).slice(),
+            ccaiServiceTypes: (this.ccaiServiceTypes || []).slice()
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            languageCodes: (this.languageCodes || []).slice(),
+            ccaiServiceTypes: (this.ccaiServiceTypes || []).map(v => CcaiServiceType[v])
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.UpdateCcaiProjectRequest
+ */
+export class UpdateCcaiProjectRequest {
+    static { this.id = 'ondewo.nlu.UpdateCcaiProjectRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new UpdateCcaiProjectRequest();
+        UpdateCcaiProjectRequest.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.ccaiProject = _instance.ccaiProject || undefined;
+        _instance.ccaiServiceFilter = _instance.ccaiServiceFilter || undefined;
+        _instance.updateMask = _instance.updateMask || undefined;
+        _instance.nluProjectName = _instance.nluProjectName || '';
+    }
+    /**
+     * 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.ccaiProject = new CcaiProject();
+                    _reader.readMessage(_instance.ccaiProject, CcaiProject.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.ccaiServiceFilter = new CcaiServiceFilter();
+                    _reader.readMessage(_instance.ccaiServiceFilter, CcaiServiceFilter.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.updateMask = new googleProtobuf000.FieldMask();
+                    _reader.readMessage(_instance.updateMask, googleProtobuf000.FieldMask.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.nluProjectName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        UpdateCcaiProjectRequest.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.ccaiProject) {
+            _writer.writeMessage(1, _instance.ccaiProject, CcaiProject.serializeBinaryToWriter);
+        }
+        if (_instance.ccaiServiceFilter) {
+            _writer.writeMessage(2, _instance.ccaiServiceFilter, CcaiServiceFilter.serializeBinaryToWriter);
+        }
+        if (_instance.updateMask) {
+            _writer.writeMessage(3, _instance.updateMask, googleProtobuf000.FieldMask.serializeBinaryToWriter);
+        }
+        if (_instance.nluProjectName) {
+            _writer.writeString(4, _instance.nluProjectName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of UpdateCcaiProjectRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.ccaiProject = _value.ccaiProject
+            ? new CcaiProject(_value.ccaiProject)
+            : undefined;
+        this.ccaiServiceFilter = _value.ccaiServiceFilter
+            ? new CcaiServiceFilter(_value.ccaiServiceFilter)
+            : undefined;
+        this.updateMask = _value.updateMask
+            ? new googleProtobuf000.FieldMask(_value.updateMask)
+            : undefined;
+        this.nluProjectName = _value.nluProjectName;
+        UpdateCcaiProjectRequest.refineValues(this);
+    }
+    get ccaiProject() {
+        return this._ccaiProject;
+    }
+    set ccaiProject(value) {
+        this._ccaiProject = value;
+    }
+    get ccaiServiceFilter() {
+        return this._ccaiServiceFilter;
+    }
+    set ccaiServiceFilter(value) {
+        this._ccaiServiceFilter = value;
+    }
+    get updateMask() {
+        return this._updateMask;
+    }
+    set updateMask(value) {
+        this._updateMask = value;
+    }
+    get nluProjectName() {
+        return this._nluProjectName;
+    }
+    set nluProjectName(value) {
+        this._nluProjectName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        UpdateCcaiProjectRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            ccaiProject: this.ccaiProject ? this.ccaiProject.toObject() : undefined,
+            ccaiServiceFilter: this.ccaiServiceFilter
+                ? this.ccaiServiceFilter.toObject()
+                : undefined,
+            updateMask: this.updateMask ? this.updateMask.toObject() : undefined,
+            nluProjectName: this.nluProjectName
+        };
+    }
+    /**
+     * 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 {
+            ccaiProject: this.ccaiProject
+                ? this.ccaiProject.toProtobufJSON(options)
+                : null,
+            ccaiServiceFilter: this.ccaiServiceFilter
+                ? this.ccaiServiceFilter.toProtobufJSON(options)
+                : null,
+            updateMask: this.updateMask
+                ? this.updateMask.toProtobufJSON(options)
+                : null,
+            nluProjectName: this.nluProjectName
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.UpdateCcaiProjectResponse
+ */
+export class UpdateCcaiProjectResponse {
+    static { this.id = 'ondewo.nlu.UpdateCcaiProjectResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new UpdateCcaiProjectResponse();
+        UpdateCcaiProjectResponse.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.errorMessage = _instance.errorMessage || '';
+    }
+    /**
+     * 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.errorMessage = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        UpdateCcaiProjectResponse.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.errorMessage) {
+            _writer.writeString(2, _instance.errorMessage);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of UpdateCcaiProjectResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.errorMessage = _value.errorMessage;
+        UpdateCcaiProjectResponse.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get errorMessage() {
+        return this._errorMessage;
+    }
+    set errorMessage(value) {
+        this._errorMessage = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        UpdateCcaiProjectResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            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 {
+            name: this.name,
+            errorMessage: this.errorMessage
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.DeleteCcaiProjectRequest
+ */
+export class DeleteCcaiProjectRequest {
+    static { this.id = 'ondewo.nlu.DeleteCcaiProjectRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new DeleteCcaiProjectRequest();
+        DeleteCcaiProjectRequest.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.nluProjectName = _instance.nluProjectName || '';
+    }
+    /**
+     * 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 4:
+                    _instance.nluProjectName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        DeleteCcaiProjectRequest.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.nluProjectName) {
+            _writer.writeString(4, _instance.nluProjectName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DeleteCcaiProjectRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.nluProjectName = _value.nluProjectName;
+        DeleteCcaiProjectRequest.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get nluProjectName() {
+        return this._nluProjectName;
+    }
+    set nluProjectName(value) {
+        this._nluProjectName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        DeleteCcaiProjectRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            nluProjectName: this.nluProjectName
+        };
+    }
+    /**
+     * 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,
+            nluProjectName: this.nluProjectName
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.nlu.DeleteCcaiProjectResponse
+ */
+export class DeleteCcaiProjectResponse {
+    static { this.id = 'ondewo.nlu.DeleteCcaiProjectResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new DeleteCcaiProjectResponse();
+        DeleteCcaiProjectResponse.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.errorMessage = _instance.errorMessage || '';
+        _instance.nluProjectName = _instance.nluProjectName || '';
+    }
+    /**
+     * 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.errorMessage = _reader.readString();
+                    break;
+                case 4:
+                    _instance.nluProjectName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        DeleteCcaiProjectResponse.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.errorMessage) {
+            _writer.writeString(2, _instance.errorMessage);
+        }
+        if (_instance.nluProjectName) {
+            _writer.writeString(4, _instance.nluProjectName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DeleteCcaiProjectResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.errorMessage = _value.errorMessage;
+        this.nluProjectName = _value.nluProjectName;
+        DeleteCcaiProjectResponse.refineValues(this);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get errorMessage() {
+        return this._errorMessage;
+    }
+    set errorMessage(value) {
+        this._errorMessage = value;
+    }
+    get nluProjectName() {
+        return this._nluProjectName;
+    }
+    set nluProjectName(value) {
+        this._nluProjectName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        DeleteCcaiProjectResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            errorMessage: this.errorMessage,
+            nluProjectName: this.nluProjectName
+        };
+    }
+    /**
+     * 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,
+            errorMessage: this.errorMessage,
+            nluProjectName: this.nluProjectName
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ccai-project.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/ccai-project.pb.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleProtobuf000 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf001 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf002 from '@ngx-grpc/well-known-types';\nimport * as ondewoNlu003 from '../../ondewo/nlu/common.pb';\nexport enum CcaiProjectStatus {\n  CCAI_PROJECT_STATUS_UNSPECIFIED = 0,\n  CCAI_PROJECT_STATUS_UNDEPLOYED = 1,\n  CCAI_PROJECT_STATUS_UPDATING = 2,\n  CCAI_PROJECT_STATUS_DEPLOYING = 3,\n  CCAI_PROJECT_STATUS_DEPLOYED = 4,\n  CCAI_PROJECT_STATUS_UNDEPLOYING = 5,\n  CCAI_PROJECT_STATUS_DELETING = 6,\n  CCAI_PROJECT_STATUS_DELETED = 7\n}\nexport enum CcaiServiceType {\n  CCAI_SERVICE_TYPE_UNSPECIFIED = 0,\n  CCAI_SERVICE_TYPE_ONDEWO_AIM = 1,\n  CCAI_SERVICE_TYPE_ONDEWO_BPI = 2,\n  CCAI_SERVICE_TYPE_ONDEWO_CSI = 3,\n  CCAI_SERVICE_TYPE_ONDEWO_NLU = 4,\n  CCAI_SERVICE_TYPE_ONDEWO_S2T = 5,\n  CCAI_SERVICE_TYPE_ONDEWO_SIP = 6,\n  CCAI_SERVICE_TYPE_ONDEWO_T2S = 7,\n  CCAI_SERVICE_TYPE_ONDEWO_VTSI = 8,\n  CCAI_SERVICE_TYPE_VTSI_RABBITMQ = 9,\n  CCAI_SERVICE_TYPE_ONDEWO_NLU_QA = 10,\n  CCAI_SERVICE_TYPE_ONDEWO_NLU_WEBHOOK = 11,\n  CCAI_SERVICE_TYPE_ONDEWO_SURVEY = 12\n}\nexport enum CcaiProjectView {\n  CCAI_PROJECT_VIEW_UNSPECIFIED = 0,\n  CCAI_PROJECT_VIEW_FULL = 1,\n  CCAI_PROJECT_VIEW_SHALLOW = 2,\n  CCAI_PROJECT_VIEW_MINIMUM = 3\n}\n/**\n * Message implementation for ondewo.nlu.CcaiProject\n */\nexport class CcaiProject implements GrpcMessage {\n  static id = 'ondewo.nlu.CcaiProject';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CcaiProject();\n    CcaiProject.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: CcaiProject) {\n    _instance.name = _instance.name || '';\n    _instance.displayName = _instance.displayName || '';\n    _instance.ownerName = _instance.ownerName || '';\n    _instance.ccaiServicesMap = _instance.ccaiServicesMap || {};\n    _instance.ccaiProjectStatus = _instance.ccaiProjectStatus || 0;\n    _instance.createdAt = _instance.createdAt || undefined;\n    _instance.modifiedAt = _instance.modifiedAt || undefined;\n    _instance.createdBy = _instance.createdBy || '';\n    _instance.modifiedBy = _instance.modifiedBy || '';\n    _instance.nluProjectName = _instance.nluProjectName || '';\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: CcaiProject,\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.ownerName = _reader.readString();\n          break;\n        case 4:\n          const msg_4 = {} as any;\n          _reader.readMessage(\n            msg_4,\n            CcaiProject.CcaiServicesMapEntry.deserializeBinaryFromReader\n          );\n          _instance.ccaiServicesMap = _instance.ccaiServicesMap || {};\n          _instance.ccaiServicesMap[msg_4.key] = msg_4.value;\n          break;\n        case 5:\n          _instance.ccaiProjectStatus = _reader.readEnum();\n          break;\n        case 6:\n          _instance.createdAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.modifiedAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.modifiedAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 8:\n          _instance.createdBy = _reader.readString();\n          break;\n        case 9:\n          _instance.modifiedBy = _reader.readString();\n          break;\n        case 10:\n          _instance.nluProjectName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CcaiProject.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: CcaiProject,\n    _writer: BinaryWriter\n  ) {\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.ownerName) {\n      _writer.writeString(3, _instance.ownerName);\n    }\n    if (!!_instance.ccaiServicesMap) {\n      const keys_4 = Object.keys(_instance.ccaiServicesMap as any);\n\n      if (keys_4.length) {\n        const repeated_4 = keys_4\n          .map(key => ({\n            key: key,\n            value: (_instance.ccaiServicesMap as any)[key]\n          }))\n          .reduce((r, v) => [...r, v], [] as any[]);\n\n        _writer.writeRepeatedMessage(\n          4,\n          repeated_4,\n          CcaiProject.CcaiServicesMapEntry.serializeBinaryToWriter\n        );\n      }\n    }\n    if (_instance.ccaiProjectStatus) {\n      _writer.writeEnum(5, _instance.ccaiProjectStatus);\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        6,\n        _instance.createdAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.modifiedAt) {\n      _writer.writeMessage(\n        7,\n        _instance.modifiedAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.createdBy) {\n      _writer.writeString(8, _instance.createdBy);\n    }\n    if (_instance.modifiedBy) {\n      _writer.writeString(9, _instance.modifiedBy);\n    }\n    if (_instance.nluProjectName) {\n      _writer.writeString(10, _instance.nluProjectName);\n    }\n  }\n\n  private _name: string;\n  private _displayName: string;\n  private _ownerName: string;\n  private _ccaiServicesMap: { [prop: string]: CcaiServiceList };\n  private _ccaiProjectStatus: CcaiProjectStatus;\n  private _createdAt?: googleProtobuf001.Timestamp;\n  private _modifiedAt?: googleProtobuf001.Timestamp;\n  private _createdBy: string;\n  private _modifiedBy: string;\n  private _nluProjectName: 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 CcaiProject to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CcaiProject.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.displayName = _value.displayName;\n    this.ownerName = _value.ownerName;\n    (this.ccaiServicesMap = _value!.ccaiServicesMap\n      ? Object.keys(_value!.ccaiServicesMap).reduce(\n          (r, k) => ({\n            ...r,\n            [k]: _value!.ccaiServicesMap![k]\n              ? new CcaiServiceList(_value!.ccaiServicesMap![k])\n              : undefined\n          }),\n          {}\n        )\n      : {}),\n      (this.ccaiProjectStatus = _value.ccaiProjectStatus);\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf001.Timestamp(_value.createdAt)\n      : undefined;\n    this.modifiedAt = _value.modifiedAt\n      ? new googleProtobuf001.Timestamp(_value.modifiedAt)\n      : undefined;\n    this.createdBy = _value.createdBy;\n    this.modifiedBy = _value.modifiedBy;\n    this.nluProjectName = _value.nluProjectName;\n    CcaiProject.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get displayName(): string {\n    return this._displayName;\n  }\n  set displayName(value: string) {\n    this._displayName = value;\n  }\n  get ownerName(): string {\n    return this._ownerName;\n  }\n  set ownerName(value: string) {\n    this._ownerName = value;\n  }\n  get ccaiServicesMap(): { [prop: string]: CcaiServiceList } {\n    return this._ccaiServicesMap;\n  }\n  set ccaiServicesMap(value: { [prop: string]: CcaiServiceList }) {\n    this._ccaiServicesMap = value;\n  }\n  get ccaiProjectStatus(): CcaiProjectStatus {\n    return this._ccaiProjectStatus;\n  }\n  set ccaiProjectStatus(value: CcaiProjectStatus) {\n    this._ccaiProjectStatus = value;\n  }\n  get createdAt(): googleProtobuf001.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._createdAt = value;\n  }\n  get modifiedAt(): googleProtobuf001.Timestamp | undefined {\n    return this._modifiedAt;\n  }\n  set modifiedAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._modifiedAt = value;\n  }\n  get createdBy(): string {\n    return this._createdBy;\n  }\n  set createdBy(value: string) {\n    this._createdBy = value;\n  }\n  get modifiedBy(): string {\n    return this._modifiedBy;\n  }\n  set modifiedBy(value: string) {\n    this._modifiedBy = value;\n  }\n  get nluProjectName(): string {\n    return this._nluProjectName;\n  }\n  set nluProjectName(value: string) {\n    this._nluProjectName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CcaiProject.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(): CcaiProject.AsObject {\n    return {\n      name: this.name,\n      displayName: this.displayName,\n      ownerName: this.ownerName,\n      ccaiServicesMap: this.ccaiServicesMap\n        ? Object.keys(this.ccaiServicesMap).reduce(\n            (r, k) => ({\n              ...r,\n              [k]: this.ccaiServicesMap![k]\n                ? this.ccaiServicesMap![k].toObject()\n                : undefined\n            }),\n            {}\n          )\n        : {},\n      ccaiProjectStatus: this.ccaiProjectStatus,\n      createdAt: this.createdAt ? this.createdAt.toObject() : undefined,\n      modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy,\n      nluProjectName: this.nluProjectName\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  ): CcaiProject.AsProtobufJSON {\n    return {\n      name: this.name,\n      displayName: this.displayName,\n      ownerName: this.ownerName,\n      ccaiServicesMap: this.ccaiServicesMap\n        ? Object.keys(this.ccaiServicesMap).reduce(\n            (r, k) => ({\n              ...r,\n              [k]: this.ccaiServicesMap![k]\n                ? this.ccaiServicesMap![k].toJSON()\n                : null\n            }),\n            {}\n          )\n        : {},\n      ccaiProjectStatus:\n        CcaiProjectStatus[\n          this.ccaiProjectStatus === null ||\n          this.ccaiProjectStatus === undefined\n            ? 0\n            : this.ccaiProjectStatus\n        ],\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,\n      modifiedAt: this.modifiedAt\n        ? this.modifiedAt.toProtobufJSON(options)\n        : null,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy,\n      nluProjectName: this.nluProjectName\n    };\n  }\n}\nexport module CcaiProject {\n  /**\n   * Standard JavaScript object representation for CcaiProject\n   */\n  export interface AsObject {\n    name: string;\n    displayName: string;\n    ownerName: string;\n    ccaiServicesMap: { [prop: string]: CcaiServiceList };\n    ccaiProjectStatus: CcaiProjectStatus;\n    createdAt?: googleProtobuf001.Timestamp.AsObject;\n    modifiedAt?: googleProtobuf001.Timestamp.AsObject;\n    createdBy: string;\n    modifiedBy: string;\n    nluProjectName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for CcaiProject\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    displayName: string;\n    ownerName: string;\n    ccaiServicesMap: { [prop: string]: CcaiServiceList };\n    ccaiProjectStatus: string;\n    createdAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    modifiedAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    createdBy: string;\n    modifiedBy: string;\n    nluProjectName: string;\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.CcaiProject.CcaiServicesMapEntry\n   */\n  export class CcaiServicesMapEntry implements GrpcMessage {\n    static id = 'ondewo.nlu.CcaiProject.CcaiServicesMapEntry';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new CcaiServicesMapEntry();\n      CcaiServicesMapEntry.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: CcaiServicesMapEntry) {\n      _instance.key = _instance.key || '';\n      _instance.value = _instance.value || undefined;\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(\n      _instance: CcaiServicesMapEntry,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.key = _reader.readString();\n            break;\n          case 2:\n            _instance.value = new CcaiServiceList();\n            _reader.readMessage(\n              _instance.value,\n              CcaiServiceList.deserializeBinaryFromReader\n            );\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      CcaiServicesMapEntry.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: CcaiServicesMapEntry,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.key) {\n        _writer.writeString(1, _instance.key);\n      }\n      if (_instance.value) {\n        _writer.writeMessage(\n          2,\n          _instance.value as any,\n          CcaiServiceList.serializeBinaryToWriter\n        );\n      }\n    }\n\n    private _key: string;\n    private _value?: CcaiServiceList;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of CcaiServicesMapEntry to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<CcaiServicesMapEntry.AsObject>) {\n      _value = _value || {};\n      this.key = _value.key;\n      this.value = _value.value ? new CcaiServiceList(_value.value) : undefined;\n      CcaiServicesMapEntry.refineValues(this);\n    }\n    get key(): string {\n      return this._key;\n    }\n    set key(value: string) {\n      this._key = value;\n    }\n    get value(): CcaiServiceList | undefined {\n      return this._value;\n    }\n    set value(value: CcaiServiceList | undefined) {\n      this._value = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      CcaiServicesMapEntry.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(): CcaiServicesMapEntry.AsObject {\n      return {\n        key: this.key,\n        value: this.value ? this.value.toObject() : undefined\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): CcaiServicesMapEntry.AsProtobufJSON {\n      return {\n        key: this.key,\n        value: this.value ? this.value.toProtobufJSON(options) : null\n      };\n    }\n  }\n  export module CcaiServicesMapEntry {\n    /**\n     * Standard JavaScript object representation for CcaiServicesMapEntry\n     */\n    export interface AsObject {\n      key: string;\n      value?: CcaiServiceList.AsObject;\n    }\n\n    /**\n     * Protobuf JSON representation for CcaiServicesMapEntry\n     */\n    export interface AsProtobufJSON {\n      key: string;\n      value: CcaiServiceList.AsProtobufJSON | null;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CcaiServiceList\n */\nexport class CcaiServiceList implements GrpcMessage {\n  static id = 'ondewo.nlu.CcaiServiceList';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CcaiServiceList();\n    CcaiServiceList.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: CcaiServiceList) {\n    _instance.ccaiServices = _instance.ccaiServices || [];\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: CcaiServiceList,\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 CcaiService();\n          _reader.readMessage(\n            messageInitializer1,\n            CcaiService.deserializeBinaryFromReader\n          );\n          (_instance.ccaiServices = _instance.ccaiServices || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CcaiServiceList.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: CcaiServiceList,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.ccaiServices && _instance.ccaiServices.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.ccaiServices as any,\n        CcaiService.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _ccaiServices?: CcaiService[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CcaiServiceList to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CcaiServiceList.AsObject>) {\n    _value = _value || {};\n    this.ccaiServices = (_value.ccaiServices || []).map(\n      m => new CcaiService(m)\n    );\n    CcaiServiceList.refineValues(this);\n  }\n  get ccaiServices(): CcaiService[] | undefined {\n    return this._ccaiServices;\n  }\n  set ccaiServices(value: CcaiService[] | undefined) {\n    this._ccaiServices = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CcaiServiceList.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(): CcaiServiceList.AsObject {\n    return {\n      ccaiServices: (this.ccaiServices || []).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  ): CcaiServiceList.AsProtobufJSON {\n    return {\n      ccaiServices: (this.ccaiServices || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module CcaiServiceList {\n  /**\n   * Standard JavaScript object representation for CcaiServiceList\n   */\n  export interface AsObject {\n    ccaiServices?: CcaiService.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for CcaiServiceList\n   */\n  export interface AsProtobufJSON {\n    ccaiServices: CcaiService.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CcaiService\n */\nexport class CcaiService implements GrpcMessage {\n  static id = 'ondewo.nlu.CcaiService';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CcaiService();\n    CcaiService.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: CcaiService) {\n    _instance.name = _instance.name || '';\n    _instance.displayName = _instance.displayName || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.grpcHost = _instance.grpcHost || '';\n    _instance.grpcPort = _instance.grpcPort || 0;\n    _instance.webgrpcHost = _instance.webgrpcHost || '';\n    _instance.webgrpcPort = _instance.webgrpcPort || 0;\n    _instance.grpcCert = _instance.grpcCert || '';\n    _instance.host = _instance.host || '';\n    _instance.port = _instance.port || 0;\n    _instance.port2 = _instance.port2 || 0;\n    _instance.httpBasicAuthToken = _instance.httpBasicAuthToken || '';\n    _instance.accountName = _instance.accountName || '';\n    _instance.accountPassword = _instance.accountPassword || '';\n    _instance.apiKey = _instance.apiKey || '';\n    _instance.ccaiServiceType = _instance.ccaiServiceType || 0;\n    _instance.ccaiProjectName = _instance.ccaiProjectName || '';\n    _instance.ccaiServiceConfig = _instance.ccaiServiceConfig || undefined;\n    _instance.createdAt = _instance.createdAt || undefined;\n    _instance.modifiedAt = _instance.modifiedAt || undefined;\n    _instance.createdBy = _instance.createdBy || '';\n    _instance.modifiedBy = _instance.modifiedBy || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: CcaiService,\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.languageCode = _reader.readString();\n          break;\n        case 4:\n          _instance.grpcHost = _reader.readString();\n          break;\n        case 5:\n          _instance.grpcPort = _reader.readInt32();\n          break;\n        case 6:\n          _instance.webgrpcHost = _reader.readString();\n          break;\n        case 7:\n          _instance.webgrpcPort = _reader.readInt32();\n          break;\n        case 8:\n          _instance.grpcCert = _reader.readString();\n          break;\n        case 9:\n          _instance.host = _reader.readString();\n          break;\n        case 10:\n          _instance.port = _reader.readInt32();\n          break;\n        case 11:\n          _instance.port2 = _reader.readInt32();\n          break;\n        case 12:\n          _instance.httpBasicAuthToken = _reader.readString();\n          break;\n        case 13:\n          _instance.accountName = _reader.readString();\n          break;\n        case 14:\n          _instance.accountPassword = _reader.readString();\n          break;\n        case 15:\n          _instance.apiKey = _reader.readString();\n          break;\n        case 16:\n          _instance.ccaiServiceType = _reader.readEnum();\n          break;\n        case 17:\n          _instance.ccaiProjectName = _reader.readString();\n          break;\n        case 18:\n          _instance.ccaiServiceConfig = new googleProtobuf002.Struct();\n          _reader.readMessage(\n            _instance.ccaiServiceConfig,\n            googleProtobuf002.Struct.deserializeBinaryFromReader\n          );\n          break;\n        case 19:\n          _instance.createdAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 20:\n          _instance.modifiedAt = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.modifiedAt,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 21:\n          _instance.createdBy = _reader.readString();\n          break;\n        case 22:\n          _instance.modifiedBy = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CcaiService.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: CcaiService,\n    _writer: BinaryWriter\n  ) {\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.languageCode) {\n      _writer.writeString(3, _instance.languageCode);\n    }\n    if (_instance.grpcHost) {\n      _writer.writeString(4, _instance.grpcHost);\n    }\n    if (_instance.grpcPort) {\n      _writer.writeInt32(5, _instance.grpcPort);\n    }\n    if (_instance.webgrpcHost) {\n      _writer.writeString(6, _instance.webgrpcHost);\n    }\n    if (_instance.webgrpcPort) {\n      _writer.writeInt32(7, _instance.webgrpcPort);\n    }\n    if (_instance.grpcCert) {\n      _writer.writeString(8, _instance.grpcCert);\n    }\n    if (_instance.host) {\n      _writer.writeString(9, _instance.host);\n    }\n    if (_instance.port) {\n      _writer.writeInt32(10, _instance.port);\n    }\n    if (_instance.port2) {\n      _writer.writeInt32(11, _instance.port2);\n    }\n    if (_instance.httpBasicAuthToken) {\n      _writer.writeString(12, _instance.httpBasicAuthToken);\n    }\n    if (_instance.accountName) {\n      _writer.writeString(13, _instance.accountName);\n    }\n    if (_instance.accountPassword) {\n      _writer.writeString(14, _instance.accountPassword);\n    }\n    if (_instance.apiKey) {\n      _writer.writeString(15, _instance.apiKey);\n    }\n    if (_instance.ccaiServiceType) {\n      _writer.writeEnum(16, _instance.ccaiServiceType);\n    }\n    if (_instance.ccaiProjectName) {\n      _writer.writeString(17, _instance.ccaiProjectName);\n    }\n    if (_instance.ccaiServiceConfig) {\n      _writer.writeMessage(\n        18,\n        _instance.ccaiServiceConfig as any,\n        googleProtobuf002.Struct.serializeBinaryToWriter\n      );\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        19,\n        _instance.createdAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.modifiedAt) {\n      _writer.writeMessage(\n        20,\n        _instance.modifiedAt as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.createdBy) {\n      _writer.writeString(21, _instance.createdBy);\n    }\n    if (_instance.modifiedBy) {\n      _writer.writeString(22, _instance.modifiedBy);\n    }\n  }\n\n  private _name: string;\n  private _displayName: string;\n  private _languageCode: string;\n  private _grpcHost: string;\n  private _grpcPort: number;\n  private _webgrpcHost: string;\n  private _webgrpcPort: number;\n  private _grpcCert: string;\n  private _host: string;\n  private _port: number;\n  private _port2: number;\n  private _httpBasicAuthToken: string;\n  private _accountName: string;\n  private _accountPassword: string;\n  private _apiKey: string;\n  private _ccaiServiceType: CcaiServiceType;\n  private _ccaiProjectName: string;\n  private _ccaiServiceConfig?: googleProtobuf002.Struct;\n  private _createdAt?: googleProtobuf001.Timestamp;\n  private _modifiedAt?: googleProtobuf001.Timestamp;\n  private _createdBy: string;\n  private _modifiedBy: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CcaiService to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CcaiService.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.displayName = _value.displayName;\n    this.languageCode = _value.languageCode;\n    this.grpcHost = _value.grpcHost;\n    this.grpcPort = _value.grpcPort;\n    this.webgrpcHost = _value.webgrpcHost;\n    this.webgrpcPort = _value.webgrpcPort;\n    this.grpcCert = _value.grpcCert;\n    this.host = _value.host;\n    this.port = _value.port;\n    this.port2 = _value.port2;\n    this.httpBasicAuthToken = _value.httpBasicAuthToken;\n    this.accountName = _value.accountName;\n    this.accountPassword = _value.accountPassword;\n    this.apiKey = _value.apiKey;\n    this.ccaiServiceType = _value.ccaiServiceType;\n    this.ccaiProjectName = _value.ccaiProjectName;\n    this.ccaiServiceConfig = _value.ccaiServiceConfig\n      ? new googleProtobuf002.Struct(_value.ccaiServiceConfig)\n      : undefined;\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf001.Timestamp(_value.createdAt)\n      : undefined;\n    this.modifiedAt = _value.modifiedAt\n      ? new googleProtobuf001.Timestamp(_value.modifiedAt)\n      : undefined;\n    this.createdBy = _value.createdBy;\n    this.modifiedBy = _value.modifiedBy;\n    CcaiService.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get displayName(): string {\n    return this._displayName;\n  }\n  set displayName(value: string) {\n    this._displayName = value;\n  }\n  get languageCode(): string {\n    return this._languageCode;\n  }\n  set languageCode(value: string) {\n    this._languageCode = value;\n  }\n  get grpcHost(): string {\n    return this._grpcHost;\n  }\n  set grpcHost(value: string) {\n    this._grpcHost = value;\n  }\n  get grpcPort(): number {\n    return this._grpcPort;\n  }\n  set grpcPort(value: number) {\n    this._grpcPort = value;\n  }\n  get webgrpcHost(): string {\n    return this._webgrpcHost;\n  }\n  set webgrpcHost(value: string) {\n    this._webgrpcHost = value;\n  }\n  get webgrpcPort(): number {\n    return this._webgrpcPort;\n  }\n  set webgrpcPort(value: number) {\n    this._webgrpcPort = value;\n  }\n  get grpcCert(): string {\n    return this._grpcCert;\n  }\n  set grpcCert(value: string) {\n    this._grpcCert = value;\n  }\n  get host(): string {\n    return this._host;\n  }\n  set host(value: string) {\n    this._host = value;\n  }\n  get port(): number {\n    return this._port;\n  }\n  set port(value: number) {\n    this._port = value;\n  }\n  get port2(): number {\n    return this._port2;\n  }\n  set port2(value: number) {\n    this._port2 = value;\n  }\n  get httpBasicAuthToken(): string {\n    return this._httpBasicAuthToken;\n  }\n  set httpBasicAuthToken(value: string) {\n    this._httpBasicAuthToken = value;\n  }\n  get accountName(): string {\n    return this._accountName;\n  }\n  set accountName(value: string) {\n    this._accountName = value;\n  }\n  get accountPassword(): string {\n    return this._accountPassword;\n  }\n  set accountPassword(value: string) {\n    this._accountPassword = value;\n  }\n  get apiKey(): string {\n    return this._apiKey;\n  }\n  set apiKey(value: string) {\n    this._apiKey = value;\n  }\n  get ccaiServiceType(): CcaiServiceType {\n    return this._ccaiServiceType;\n  }\n  set ccaiServiceType(value: CcaiServiceType) {\n    this._ccaiServiceType = value;\n  }\n  get ccaiProjectName(): string {\n    return this._ccaiProjectName;\n  }\n  set ccaiProjectName(value: string) {\n    this._ccaiProjectName = value;\n  }\n  get ccaiServiceConfig(): googleProtobuf002.Struct | undefined {\n    return this._ccaiServiceConfig;\n  }\n  set ccaiServiceConfig(value: googleProtobuf002.Struct | undefined) {\n    this._ccaiServiceConfig = value;\n  }\n  get createdAt(): googleProtobuf001.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._createdAt = value;\n  }\n  get modifiedAt(): googleProtobuf001.Timestamp | undefined {\n    return this._modifiedAt;\n  }\n  set modifiedAt(value: googleProtobuf001.Timestamp | undefined) {\n    this._modifiedAt = value;\n  }\n  get createdBy(): string {\n    return this._createdBy;\n  }\n  set createdBy(value: string) {\n    this._createdBy = value;\n  }\n  get modifiedBy(): string {\n    return this._modifiedBy;\n  }\n  set modifiedBy(value: string) {\n    this._modifiedBy = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CcaiService.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(): CcaiService.AsObject {\n    return {\n      name: this.name,\n      displayName: this.displayName,\n      languageCode: this.languageCode,\n      grpcHost: this.grpcHost,\n      grpcPort: this.grpcPort,\n      webgrpcHost: this.webgrpcHost,\n      webgrpcPort: this.webgrpcPort,\n      grpcCert: this.grpcCert,\n      host: this.host,\n      port: this.port,\n      port2: this.port2,\n      httpBasicAuthToken: this.httpBasicAuthToken,\n      accountName: this.accountName,\n      accountPassword: this.accountPassword,\n      apiKey: this.apiKey,\n      ccaiServiceType: this.ccaiServiceType,\n      ccaiProjectName: this.ccaiProjectName,\n      ccaiServiceConfig: this.ccaiServiceConfig\n        ? this.ccaiServiceConfig.toObject()\n        : undefined,\n      createdAt: this.createdAt ? this.createdAt.toObject() : undefined,\n      modifiedAt: this.modifiedAt ? this.modifiedAt.toObject() : undefined,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): CcaiService.AsProtobufJSON {\n    return {\n      name: this.name,\n      displayName: this.displayName,\n      languageCode: this.languageCode,\n      grpcHost: this.grpcHost,\n      grpcPort: this.grpcPort,\n      webgrpcHost: this.webgrpcHost,\n      webgrpcPort: this.webgrpcPort,\n      grpcCert: this.grpcCert,\n      host: this.host,\n      port: this.port,\n      port2: this.port2,\n      httpBasicAuthToken: this.httpBasicAuthToken,\n      accountName: this.accountName,\n      accountPassword: this.accountPassword,\n      apiKey: this.apiKey,\n      ccaiServiceType:\n        CcaiServiceType[\n          this.ccaiServiceType === null || this.ccaiServiceType === undefined\n            ? 0\n            : this.ccaiServiceType\n        ],\n      ccaiProjectName: this.ccaiProjectName,\n      ccaiServiceConfig: this.ccaiServiceConfig\n        ? this.ccaiServiceConfig.toProtobufJSON(options)\n        : null,\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,\n      modifiedAt: this.modifiedAt\n        ? this.modifiedAt.toProtobufJSON(options)\n        : null,\n      createdBy: this.createdBy,\n      modifiedBy: this.modifiedBy\n    };\n  }\n}\nexport module CcaiService {\n  /**\n   * Standard JavaScript object representation for CcaiService\n   */\n  export interface AsObject {\n    name: string;\n    displayName: string;\n    languageCode: string;\n    grpcHost: string;\n    grpcPort: number;\n    webgrpcHost: string;\n    webgrpcPort: number;\n    grpcCert: string;\n    host: string;\n    port: number;\n    port2: number;\n    httpBasicAuthToken: string;\n    accountName: string;\n    accountPassword: string;\n    apiKey: string;\n    ccaiServiceType: CcaiServiceType;\n    ccaiProjectName: string;\n    ccaiServiceConfig?: googleProtobuf002.Struct.AsObject;\n    createdAt?: googleProtobuf001.Timestamp.AsObject;\n    modifiedAt?: googleProtobuf001.Timestamp.AsObject;\n    createdBy: string;\n    modifiedBy: string;\n  }\n\n  /**\n   * Protobuf JSON representation for CcaiService\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    displayName: string;\n    languageCode: string;\n    grpcHost: string;\n    grpcPort: number;\n    webgrpcHost: string;\n    webgrpcPort: number;\n    grpcCert: string;\n    host: string;\n    port: number;\n    port2: number;\n    httpBasicAuthToken: string;\n    accountName: string;\n    accountPassword: string;\n    apiKey: string;\n    ccaiServiceType: string;\n    ccaiProjectName: string;\n    ccaiServiceConfig: googleProtobuf002.Struct.AsProtobufJSON | null;\n    createdAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    modifiedAt: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    createdBy: string;\n    modifiedBy: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CreateCcaiProjectRequest\n */\nexport class CreateCcaiProjectRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CreateCcaiProjectRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CreateCcaiProjectRequest();\n    CreateCcaiProjectRequest.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: CreateCcaiProjectRequest) {\n    _instance.ccaiProject = _instance.ccaiProject || undefined;\n    _instance.nluProjectName = _instance.nluProjectName || '';\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: CreateCcaiProjectRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.ccaiProject = new CcaiProject();\n          _reader.readMessage(\n            _instance.ccaiProject,\n            CcaiProject.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.nluProjectName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CreateCcaiProjectRequest.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: CreateCcaiProjectRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.ccaiProject) {\n      _writer.writeMessage(\n        1,\n        _instance.ccaiProject as any,\n        CcaiProject.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nluProjectName) {\n      _writer.writeString(4, _instance.nluProjectName);\n    }\n  }\n\n  private _ccaiProject?: CcaiProject;\n  private _nluProjectName: 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 CreateCcaiProjectRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CreateCcaiProjectRequest.AsObject>) {\n    _value = _value || {};\n    this.ccaiProject = _value.ccaiProject\n      ? new CcaiProject(_value.ccaiProject)\n      : undefined;\n    this.nluProjectName = _value.nluProjectName;\n    CreateCcaiProjectRequest.refineValues(this);\n  }\n  get ccaiProject(): CcaiProject | undefined {\n    return this._ccaiProject;\n  }\n  set ccaiProject(value: CcaiProject | undefined) {\n    this._ccaiProject = value;\n  }\n  get nluProjectName(): string {\n    return this._nluProjectName;\n  }\n  set nluProjectName(value: string) {\n    this._nluProjectName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CreateCcaiProjectRequest.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(): CreateCcaiProjectRequest.AsObject {\n    return {\n      ccaiProject: this.ccaiProject ? this.ccaiProject.toObject() : undefined,\n      nluProjectName: this.nluProjectName\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  ): CreateCcaiProjectRequest.AsProtobufJSON {\n    return {\n      ccaiProject: this.ccaiProject\n        ? this.ccaiProject.toProtobufJSON(options)\n        : null,\n      nluProjectName: this.nluProjectName\n    };\n  }\n}\nexport module CreateCcaiProjectRequest {\n  /**\n   * Standard JavaScript object representation for CreateCcaiProjectRequest\n   */\n  export interface AsObject {\n    ccaiProject?: CcaiProject.AsObject;\n    nluProjectName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for CreateCcaiProjectRequest\n   */\n  export interface AsProtobufJSON {\n    ccaiProject: CcaiProject.AsProtobufJSON | null;\n    nluProjectName: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CreateCcaiProjectResponse\n */\nexport class CreateCcaiProjectResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.CreateCcaiProjectResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CreateCcaiProjectResponse();\n    CreateCcaiProjectResponse.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: CreateCcaiProjectResponse) {\n    _instance.ccaiProject = _instance.ccaiProject || undefined;\n    _instance.errorMessage = _instance.errorMessage || '';\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: CreateCcaiProjectResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.ccaiProject = new CcaiProject();\n          _reader.readMessage(\n            _instance.ccaiProject,\n            CcaiProject.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.errorMessage = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CreateCcaiProjectResponse.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: CreateCcaiProjectResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.ccaiProject) {\n      _writer.writeMessage(\n        1,\n        _instance.ccaiProject as any,\n        CcaiProject.serializeBinaryToWriter\n      );\n    }\n    if (_instance.errorMessage) {\n      _writer.writeString(2, _instance.errorMessage);\n    }\n  }\n\n  private _ccaiProject?: CcaiProject;\n  private _errorMessage: 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 CreateCcaiProjectResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CreateCcaiProjectResponse.AsObject>) {\n    _value = _value || {};\n    this.ccaiProject = _value.ccaiProject\n      ? new CcaiProject(_value.ccaiProject)\n      : undefined;\n    this.errorMessage = _value.errorMessage;\n    CreateCcaiProjectResponse.refineValues(this);\n  }\n  get ccaiProject(): CcaiProject | undefined {\n    return this._ccaiProject;\n  }\n  set ccaiProject(value: CcaiProject | undefined) {\n    this._ccaiProject = value;\n  }\n  get errorMessage(): string {\n    return this._errorMessage;\n  }\n  set errorMessage(value: string) {\n    this._errorMessage = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CreateCcaiProjectResponse.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(): CreateCcaiProjectResponse.AsObject {\n    return {\n      ccaiProject: this.ccaiProject ? this.ccaiProject.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  ): CreateCcaiProjectResponse.AsProtobufJSON {\n    return {\n      ccaiProject: this.ccaiProject\n        ? this.ccaiProject.toProtobufJSON(options)\n        : null,\n      errorMessage: this.errorMessage\n    };\n  }\n}\nexport module CreateCcaiProjectResponse {\n  /**\n   * Standard JavaScript object representation for CreateCcaiProjectResponse\n   */\n  export interface AsObject {\n    ccaiProject?: CcaiProject.AsObject;\n    errorMessage: string;\n  }\n\n  /**\n   * Protobuf JSON representation for CreateCcaiProjectResponse\n   */\n  export interface AsProtobufJSON {\n    ccaiProject: CcaiProject.AsProtobufJSON | null;\n    errorMessage: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetCcaiProjectRequest\n */\nexport class GetCcaiProjectRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetCcaiProjectRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetCcaiProjectRequest();\n    GetCcaiProjectRequest.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: GetCcaiProjectRequest) {\n    _instance.name = _instance.name || '';\n    _instance.ccaiProjectView = _instance.ccaiProjectView || 0;\n    _instance.ccaiServiceFilter = _instance.ccaiServiceFilter || undefined;\n    _instance.nluProjectName = _instance.nluProjectName || '';\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: GetCcaiProjectRequest,\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.ccaiProjectView = _reader.readEnum();\n          break;\n        case 3:\n          _instance.ccaiServiceFilter = new CcaiServiceFilter();\n          _reader.readMessage(\n            _instance.ccaiServiceFilter,\n            CcaiServiceFilter.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.nluProjectName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetCcaiProjectRequest.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: GetCcaiProjectRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.ccaiProjectView) {\n      _writer.writeEnum(2, _instance.ccaiProjectView);\n    }\n    if (_instance.ccaiServiceFilter) {\n      _writer.writeMessage(\n        3,\n        _instance.ccaiServiceFilter as any,\n        CcaiServiceFilter.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nluProjectName) {\n      _writer.writeString(4, _instance.nluProjectName);\n    }\n  }\n\n  private _name: string;\n  private _ccaiProjectView: CcaiProjectView;\n  private _ccaiServiceFilter?: CcaiServiceFilter;\n  private _nluProjectName: 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 GetCcaiProjectRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetCcaiProjectRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.ccaiProjectView = _value.ccaiProjectView;\n    this.ccaiServiceFilter = _value.ccaiServiceFilter\n      ? new CcaiServiceFilter(_value.ccaiServiceFilter)\n      : undefined;\n    this.nluProjectName = _value.nluProjectName;\n    GetCcaiProjectRequest.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get ccaiProjectView(): CcaiProjectView {\n    return this._ccaiProjectView;\n  }\n  set ccaiProjectView(value: CcaiProjectView) {\n    this._ccaiProjectView = value;\n  }\n  get ccaiServiceFilter(): CcaiServiceFilter | undefined {\n    return this._ccaiServiceFilter;\n  }\n  set ccaiServiceFilter(value: CcaiServiceFilter | undefined) {\n    this._ccaiServiceFilter = value;\n  }\n  get nluProjectName(): string {\n    return this._nluProjectName;\n  }\n  set nluProjectName(value: string) {\n    this._nluProjectName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetCcaiProjectRequest.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(): GetCcaiProjectRequest.AsObject {\n    return {\n      name: this.name,\n      ccaiProjectView: this.ccaiProjectView,\n      ccaiServiceFilter: this.ccaiServiceFilter\n        ? this.ccaiServiceFilter.toObject()\n        : undefined,\n      nluProjectName: this.nluProjectName\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  ): GetCcaiProjectRequest.AsProtobufJSON {\n    return {\n      name: this.name,\n      ccaiProjectView:\n        CcaiProjectView[\n          this.ccaiProjectView === null || this.ccaiProjectView === undefined\n            ? 0\n            : this.ccaiProjectView\n        ],\n      ccaiServiceFilter: this.ccaiServiceFilter\n        ? this.ccaiServiceFilter.toProtobufJSON(options)\n        : null,\n      nluProjectName: this.nluProjectName\n    };\n  }\n}\nexport module GetCcaiProjectRequest {\n  /**\n   * Standard JavaScript object representation for GetCcaiProjectRequest\n   */\n  export interface AsObject {\n    name: string;\n    ccaiProjectView: CcaiProjectView;\n    ccaiServiceFilter?: CcaiServiceFilter.AsObject;\n    nluProjectName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetCcaiProjectRequest\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    ccaiProjectView: string;\n    ccaiServiceFilter: CcaiServiceFilter.AsProtobufJSON | null;\n    nluProjectName: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListCcaiProjectsRequest\n */\nexport class ListCcaiProjectsRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListCcaiProjectsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListCcaiProjectsRequest();\n    ListCcaiProjectsRequest.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: ListCcaiProjectsRequest) {\n    _instance.ccaiProjectView = _instance.ccaiProjectView || 0;\n    _instance.ccaiServiceFilter = _instance.ccaiServiceFilter || undefined;\n    _instance.ccaiProjectSorting = _instance.ccaiProjectSorting || undefined;\n    _instance.pageToken = _instance.pageToken || '';\n    _instance.nluProjectName = _instance.nluProjectName || '';\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: ListCcaiProjectsRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.ccaiProjectView = _reader.readEnum();\n          break;\n        case 2:\n          _instance.ccaiServiceFilter = new CcaiServiceFilter();\n          _reader.readMessage(\n            _instance.ccaiServiceFilter,\n            CcaiServiceFilter.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.ccaiProjectSorting = new CcaiProjectSorting();\n          _reader.readMessage(\n            _instance.ccaiProjectSorting,\n            CcaiProjectSorting.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.pageToken = _reader.readString();\n          break;\n        case 5:\n          _instance.nluProjectName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListCcaiProjectsRequest.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: ListCcaiProjectsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.ccaiProjectView) {\n      _writer.writeEnum(1, _instance.ccaiProjectView);\n    }\n    if (_instance.ccaiServiceFilter) {\n      _writer.writeMessage(\n        2,\n        _instance.ccaiServiceFilter as any,\n        CcaiServiceFilter.serializeBinaryToWriter\n      );\n    }\n    if (_instance.ccaiProjectSorting) {\n      _writer.writeMessage(\n        3,\n        _instance.ccaiProjectSorting as any,\n        CcaiProjectSorting.serializeBinaryToWriter\n      );\n    }\n    if (_instance.pageToken) {\n      _writer.writeString(4, _instance.pageToken);\n    }\n    if (_instance.nluProjectName) {\n      _writer.writeString(5, _instance.nluProjectName);\n    }\n  }\n\n  private _ccaiProjectView: CcaiProjectView;\n  private _ccaiServiceFilter?: CcaiServiceFilter;\n  private _ccaiProjectSorting?: CcaiProjectSorting;\n  private _pageToken: string;\n  private _nluProjectName: 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 ListCcaiProjectsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListCcaiProjectsRequest.AsObject>) {\n    _value = _value || {};\n    this.ccaiProjectView = _value.ccaiProjectView;\n    this.ccaiServiceFilter = _value.ccaiServiceFilter\n      ? new CcaiServiceFilter(_value.ccaiServiceFilter)\n      : undefined;\n    this.ccaiProjectSorting = _value.ccaiProjectSorting\n      ? new CcaiProjectSorting(_value.ccaiProjectSorting)\n      : undefined;\n    this.pageToken = _value.pageToken;\n    this.nluProjectName = _value.nluProjectName;\n    ListCcaiProjectsRequest.refineValues(this);\n  }\n  get ccaiProjectView(): CcaiProjectView {\n    return this._ccaiProjectView;\n  }\n  set ccaiProjectView(value: CcaiProjectView) {\n    this._ccaiProjectView = value;\n  }\n  get ccaiServiceFilter(): CcaiServiceFilter | undefined {\n    return this._ccaiServiceFilter;\n  }\n  set ccaiServiceFilter(value: CcaiServiceFilter | undefined) {\n    this._ccaiServiceFilter = value;\n  }\n  get ccaiProjectSorting(): CcaiProjectSorting | undefined {\n    return this._ccaiProjectSorting;\n  }\n  set ccaiProjectSorting(value: CcaiProjectSorting | undefined) {\n    this._ccaiProjectSorting = value;\n  }\n  get pageToken(): string {\n    return this._pageToken;\n  }\n  set pageToken(value: string) {\n    this._pageToken = value;\n  }\n  get nluProjectName(): string {\n    return this._nluProjectName;\n  }\n  set nluProjectName(value: string) {\n    this._nluProjectName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListCcaiProjectsRequest.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(): ListCcaiProjectsRequest.AsObject {\n    return {\n      ccaiProjectView: this.ccaiProjectView,\n      ccaiServiceFilter: this.ccaiServiceFilter\n        ? this.ccaiServiceFilter.toObject()\n        : undefined,\n      ccaiProjectSorting: this.ccaiProjectSorting\n        ? this.ccaiProjectSorting.toObject()\n        : undefined,\n      pageToken: this.pageToken,\n      nluProjectName: this.nluProjectName\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  ): ListCcaiProjectsRequest.AsProtobufJSON {\n    return {\n      ccaiProjectView:\n        CcaiProjectView[\n          this.ccaiProjectView === null || this.ccaiProjectView === undefined\n            ? 0\n            : this.ccaiProjectView\n        ],\n      ccaiServiceFilter: this.ccaiServiceFilter\n        ? this.ccaiServiceFilter.toProtobufJSON(options)\n        : null,\n      ccaiProjectSorting: this.ccaiProjectSorting\n        ? this.ccaiProjectSorting.toProtobufJSON(options)\n        : null,\n      pageToken: this.pageToken,\n      nluProjectName: this.nluProjectName\n    };\n  }\n}\nexport module ListCcaiProjectsRequest {\n  /**\n   * Standard JavaScript object representation for ListCcaiProjectsRequest\n   */\n  export interface AsObject {\n    ccaiProjectView: CcaiProjectView;\n    ccaiServiceFilter?: CcaiServiceFilter.AsObject;\n    ccaiProjectSorting?: CcaiProjectSorting.AsObject;\n    pageToken: string;\n    nluProjectName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListCcaiProjectsRequest\n   */\n  export interface AsProtobufJSON {\n    ccaiProjectView: string;\n    ccaiServiceFilter: CcaiServiceFilter.AsProtobufJSON | null;\n    ccaiProjectSorting: CcaiProjectSorting.AsProtobufJSON | null;\n    pageToken: string;\n    nluProjectName: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListCcaiProjectsResponse\n */\nexport class ListCcaiProjectsResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListCcaiProjectsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListCcaiProjectsResponse();\n    ListCcaiProjectsResponse.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: ListCcaiProjectsResponse) {\n    _instance.ccaiProjects = _instance.ccaiProjects || [];\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: ListCcaiProjectsResponse,\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 CcaiProject();\n          _reader.readMessage(\n            messageInitializer1,\n            CcaiProject.deserializeBinaryFromReader\n          );\n          (_instance.ccaiProjects = _instance.ccaiProjects || []).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    ListCcaiProjectsResponse.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: ListCcaiProjectsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.ccaiProjects && _instance.ccaiProjects.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.ccaiProjects as any,\n        CcaiProject.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _ccaiProjects?: CcaiProject[];\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 ListCcaiProjectsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListCcaiProjectsResponse.AsObject>) {\n    _value = _value || {};\n    this.ccaiProjects = (_value.ccaiProjects || []).map(\n      m => new CcaiProject(m)\n    );\n    this.nextPageToken = _value.nextPageToken;\n    ListCcaiProjectsResponse.refineValues(this);\n  }\n  get ccaiProjects(): CcaiProject[] | undefined {\n    return this._ccaiProjects;\n  }\n  set ccaiProjects(value: CcaiProject[] | undefined) {\n    this._ccaiProjects = value;\n  }\n  get nextPageToken(): string {\n    return this._nextPageToken;\n  }\n  set nextPageToken(value: string) {\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    ListCcaiProjectsResponse.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(): ListCcaiProjectsResponse.AsObject {\n    return {\n      ccaiProjects: (this.ccaiProjects || []).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  ): ListCcaiProjectsResponse.AsProtobufJSON {\n    return {\n      ccaiProjects: (this.ccaiProjects || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListCcaiProjectsResponse {\n  /**\n   * Standard JavaScript object representation for ListCcaiProjectsResponse\n   */\n  export interface AsObject {\n    ccaiProjects?: CcaiProject.AsObject[];\n    nextPageToken: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListCcaiProjectsResponse\n   */\n  export interface AsProtobufJSON {\n    ccaiProjects: CcaiProject.AsProtobufJSON[] | null;\n    nextPageToken: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CcaiProjectSorting\n */\nexport class CcaiProjectSorting implements GrpcMessage {\n  static id = 'ondewo.nlu.CcaiProjectSorting';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CcaiProjectSorting();\n    CcaiProjectSorting.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: CcaiProjectSorting) {\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: CcaiProjectSorting,\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    CcaiProjectSorting.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: CcaiProjectSorting,\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: CcaiProjectSorting.CcaiProjectSortingField;\n  private _sortingMode: ondewoNlu003.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 CcaiProjectSorting to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CcaiProjectSorting.AsObject>) {\n    _value = _value || {};\n    this.sortingField = _value.sortingField;\n    this.sortingMode = _value.sortingMode;\n    CcaiProjectSorting.refineValues(this);\n  }\n  get sortingField(): CcaiProjectSorting.CcaiProjectSortingField {\n    return this._sortingField;\n  }\n  set sortingField(value: CcaiProjectSorting.CcaiProjectSortingField) {\n    this._sortingField = value;\n  }\n  get sortingMode(): ondewoNlu003.SortingMode {\n    return this._sortingMode;\n  }\n  set sortingMode(value: ondewoNlu003.SortingMode) {\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    CcaiProjectSorting.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(): CcaiProjectSorting.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  ): CcaiProjectSorting.AsProtobufJSON {\n    return {\n      sortingField:\n        CcaiProjectSorting.CcaiProjectSortingField[\n          this.sortingField === null || this.sortingField === undefined\n            ? 0\n            : this.sortingField\n        ],\n      sortingMode:\n        ondewoNlu003.SortingMode[\n          this.sortingMode === null || this.sortingMode === undefined\n            ? 0\n            : this.sortingMode\n        ]\n    };\n  }\n}\nexport module CcaiProjectSorting {\n  /**\n   * Standard JavaScript object representation for CcaiProjectSorting\n   */\n  export interface AsObject {\n    sortingField: CcaiProjectSorting.CcaiProjectSortingField;\n    sortingMode: ondewoNlu003.SortingMode;\n  }\n\n  /**\n   * Protobuf JSON representation for CcaiProjectSorting\n   */\n  export interface AsProtobufJSON {\n    sortingField: string;\n    sortingMode: string;\n  }\n  export enum CcaiProjectSortingField {\n    NO_CCAI_PROJECT_SORTING = 0,\n    SORT_CCAI_PROJECT_BY_NAME = 1,\n    SORT_CCAI_PROJECT_BY_DISPLAY_NAME = 2,\n    SORT_CCAI_PROJECT_BY_CREATION_DATE = 3,\n    SORT_CCAI_PROJECT_BY_LAST_MODIFIED = 4\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CcaiServiceFilter\n */\nexport class CcaiServiceFilter implements GrpcMessage {\n  static id = 'ondewo.nlu.CcaiServiceFilter';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CcaiServiceFilter();\n    CcaiServiceFilter.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: CcaiServiceFilter) {\n    _instance.languageCodes = _instance.languageCodes || [];\n    _instance.ccaiServiceTypes = _instance.ccaiServiceTypes || [];\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: CcaiServiceFilter,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.languageCodes = _instance.languageCodes || []).push(\n            _reader.readString()\n          );\n          break;\n        case 2:\n          (_instance.ccaiServiceTypes = _instance.ccaiServiceTypes || []).push(\n            ...(_reader.readPackedEnum() || [])\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CcaiServiceFilter.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: CcaiServiceFilter,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.languageCodes && _instance.languageCodes.length) {\n      _writer.writeRepeatedString(1, _instance.languageCodes);\n    }\n    if (_instance.ccaiServiceTypes && _instance.ccaiServiceTypes.length) {\n      _writer.writePackedEnum(2, _instance.ccaiServiceTypes);\n    }\n  }\n\n  private _languageCodes: string[];\n  private _ccaiServiceTypes: CcaiServiceType[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CcaiServiceFilter to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CcaiServiceFilter.AsObject>) {\n    _value = _value || {};\n    this.languageCodes = (_value.languageCodes || []).slice();\n    this.ccaiServiceTypes = (_value.ccaiServiceTypes || []).slice();\n    CcaiServiceFilter.refineValues(this);\n  }\n  get languageCodes(): string[] {\n    return this._languageCodes;\n  }\n  set languageCodes(value: string[]) {\n    this._languageCodes = value;\n  }\n  get ccaiServiceTypes(): CcaiServiceType[] {\n    return this._ccaiServiceTypes;\n  }\n  set ccaiServiceTypes(value: CcaiServiceType[]) {\n    this._ccaiServiceTypes = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CcaiServiceFilter.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(): CcaiServiceFilter.AsObject {\n    return {\n      languageCodes: (this.languageCodes || []).slice(),\n      ccaiServiceTypes: (this.ccaiServiceTypes || []).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  ): CcaiServiceFilter.AsProtobufJSON {\n    return {\n      languageCodes: (this.languageCodes || []).slice(),\n      ccaiServiceTypes: (this.ccaiServiceTypes || []).map(\n        v => CcaiServiceType[v]\n      )\n    };\n  }\n}\nexport module CcaiServiceFilter {\n  /**\n   * Standard JavaScript object representation for CcaiServiceFilter\n   */\n  export interface AsObject {\n    languageCodes: string[];\n    ccaiServiceTypes: CcaiServiceType[];\n  }\n\n  /**\n   * Protobuf JSON representation for CcaiServiceFilter\n   */\n  export interface AsProtobufJSON {\n    languageCodes: string[];\n    ccaiServiceTypes: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.UpdateCcaiProjectRequest\n */\nexport class UpdateCcaiProjectRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.UpdateCcaiProjectRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new UpdateCcaiProjectRequest();\n    UpdateCcaiProjectRequest.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: UpdateCcaiProjectRequest) {\n    _instance.ccaiProject = _instance.ccaiProject || undefined;\n    _instance.ccaiServiceFilter = _instance.ccaiServiceFilter || undefined;\n    _instance.updateMask = _instance.updateMask || undefined;\n    _instance.nluProjectName = _instance.nluProjectName || '';\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: UpdateCcaiProjectRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.ccaiProject = new CcaiProject();\n          _reader.readMessage(\n            _instance.ccaiProject,\n            CcaiProject.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.ccaiServiceFilter = new CcaiServiceFilter();\n          _reader.readMessage(\n            _instance.ccaiServiceFilter,\n            CcaiServiceFilter.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.updateMask = new googleProtobuf000.FieldMask();\n          _reader.readMessage(\n            _instance.updateMask,\n            googleProtobuf000.FieldMask.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.nluProjectName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    UpdateCcaiProjectRequest.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: UpdateCcaiProjectRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.ccaiProject) {\n      _writer.writeMessage(\n        1,\n        _instance.ccaiProject as any,\n        CcaiProject.serializeBinaryToWriter\n      );\n    }\n    if (_instance.ccaiServiceFilter) {\n      _writer.writeMessage(\n        2,\n        _instance.ccaiServiceFilter as any,\n        CcaiServiceFilter.serializeBinaryToWriter\n      );\n    }\n    if (_instance.updateMask) {\n      _writer.writeMessage(\n        3,\n        _instance.updateMask as any,\n        googleProtobuf000.FieldMask.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nluProjectName) {\n      _writer.writeString(4, _instance.nluProjectName);\n    }\n  }\n\n  private _ccaiProject?: CcaiProject;\n  private _ccaiServiceFilter?: CcaiServiceFilter;\n  private _updateMask?: googleProtobuf000.FieldMask;\n  private _nluProjectName: 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 UpdateCcaiProjectRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<UpdateCcaiProjectRequest.AsObject>) {\n    _value = _value || {};\n    this.ccaiProject = _value.ccaiProject\n      ? new CcaiProject(_value.ccaiProject)\n      : undefined;\n    this.ccaiServiceFilter = _value.ccaiServiceFilter\n      ? new CcaiServiceFilter(_value.ccaiServiceFilter)\n      : undefined;\n    this.updateMask = _value.updateMask\n      ? new googleProtobuf000.FieldMask(_value.updateMask)\n      : undefined;\n    this.nluProjectName = _value.nluProjectName;\n    UpdateCcaiProjectRequest.refineValues(this);\n  }\n  get ccaiProject(): CcaiProject | undefined {\n    return this._ccaiProject;\n  }\n  set ccaiProject(value: CcaiProject | undefined) {\n    this._ccaiProject = value;\n  }\n  get ccaiServiceFilter(): CcaiServiceFilter | undefined {\n    return this._ccaiServiceFilter;\n  }\n  set ccaiServiceFilter(value: CcaiServiceFilter | undefined) {\n    this._ccaiServiceFilter = value;\n  }\n  get updateMask(): googleProtobuf000.FieldMask | undefined {\n    return this._updateMask;\n  }\n  set updateMask(value: googleProtobuf000.FieldMask | undefined) {\n    this._updateMask = value;\n  }\n  get nluProjectName(): string {\n    return this._nluProjectName;\n  }\n  set nluProjectName(value: string) {\n    this._nluProjectName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    UpdateCcaiProjectRequest.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(): UpdateCcaiProjectRequest.AsObject {\n    return {\n      ccaiProject: this.ccaiProject ? this.ccaiProject.toObject() : undefined,\n      ccaiServiceFilter: this.ccaiServiceFilter\n        ? this.ccaiServiceFilter.toObject()\n        : undefined,\n      updateMask: this.updateMask ? this.updateMask.toObject() : undefined,\n      nluProjectName: this.nluProjectName\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  ): UpdateCcaiProjectRequest.AsProtobufJSON {\n    return {\n      ccaiProject: this.ccaiProject\n        ? this.ccaiProject.toProtobufJSON(options)\n        : null,\n      ccaiServiceFilter: this.ccaiServiceFilter\n        ? this.ccaiServiceFilter.toProtobufJSON(options)\n        : null,\n      updateMask: this.updateMask\n        ? this.updateMask.toProtobufJSON(options)\n        : null,\n      nluProjectName: this.nluProjectName\n    };\n  }\n}\nexport module UpdateCcaiProjectRequest {\n  /**\n   * Standard JavaScript object representation for UpdateCcaiProjectRequest\n   */\n  export interface AsObject {\n    ccaiProject?: CcaiProject.AsObject;\n    ccaiServiceFilter?: CcaiServiceFilter.AsObject;\n    updateMask?: googleProtobuf000.FieldMask.AsObject;\n    nluProjectName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for UpdateCcaiProjectRequest\n   */\n  export interface AsProtobufJSON {\n    ccaiProject: CcaiProject.AsProtobufJSON | null;\n    ccaiServiceFilter: CcaiServiceFilter.AsProtobufJSON | null;\n    updateMask: googleProtobuf000.FieldMask.AsProtobufJSON | null;\n    nluProjectName: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.UpdateCcaiProjectResponse\n */\nexport class UpdateCcaiProjectResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.UpdateCcaiProjectResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new UpdateCcaiProjectResponse();\n    UpdateCcaiProjectResponse.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: UpdateCcaiProjectResponse) {\n    _instance.name = _instance.name || '';\n    _instance.errorMessage = _instance.errorMessage || '';\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: UpdateCcaiProjectResponse,\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.errorMessage = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    UpdateCcaiProjectResponse.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: UpdateCcaiProjectResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.errorMessage) {\n      _writer.writeString(2, _instance.errorMessage);\n    }\n  }\n\n  private _name: string;\n  private _errorMessage: 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 UpdateCcaiProjectResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<UpdateCcaiProjectResponse.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.errorMessage = _value.errorMessage;\n    UpdateCcaiProjectResponse.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get errorMessage(): string {\n    return this._errorMessage;\n  }\n  set errorMessage(value: string) {\n    this._errorMessage = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    UpdateCcaiProjectResponse.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(): UpdateCcaiProjectResponse.AsObject {\n    return {\n      name: this.name,\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  ): UpdateCcaiProjectResponse.AsProtobufJSON {\n    return {\n      name: this.name,\n      errorMessage: this.errorMessage\n    };\n  }\n}\nexport module UpdateCcaiProjectResponse {\n  /**\n   * Standard JavaScript object representation for UpdateCcaiProjectResponse\n   */\n  export interface AsObject {\n    name: string;\n    errorMessage: string;\n  }\n\n  /**\n   * Protobuf JSON representation for UpdateCcaiProjectResponse\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    errorMessage: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.DeleteCcaiProjectRequest\n */\nexport class DeleteCcaiProjectRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.DeleteCcaiProjectRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new DeleteCcaiProjectRequest();\n    DeleteCcaiProjectRequest.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: DeleteCcaiProjectRequest) {\n    _instance.name = _instance.name || '';\n    _instance.nluProjectName = _instance.nluProjectName || '';\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: DeleteCcaiProjectRequest,\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 4:\n          _instance.nluProjectName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    DeleteCcaiProjectRequest.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: DeleteCcaiProjectRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.nluProjectName) {\n      _writer.writeString(4, _instance.nluProjectName);\n    }\n  }\n\n  private _name: string;\n  private _nluProjectName: 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 DeleteCcaiProjectRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<DeleteCcaiProjectRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.nluProjectName = _value.nluProjectName;\n    DeleteCcaiProjectRequest.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get nluProjectName(): string {\n    return this._nluProjectName;\n  }\n  set nluProjectName(value: string) {\n    this._nluProjectName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    DeleteCcaiProjectRequest.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(): DeleteCcaiProjectRequest.AsObject {\n    return {\n      name: this.name,\n      nluProjectName: this.nluProjectName\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  ): DeleteCcaiProjectRequest.AsProtobufJSON {\n    return {\n      name: this.name,\n      nluProjectName: this.nluProjectName\n    };\n  }\n}\nexport module DeleteCcaiProjectRequest {\n  /**\n   * Standard JavaScript object representation for DeleteCcaiProjectRequest\n   */\n  export interface AsObject {\n    name: string;\n    nluProjectName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for DeleteCcaiProjectRequest\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    nluProjectName: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.DeleteCcaiProjectResponse\n */\nexport class DeleteCcaiProjectResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.DeleteCcaiProjectResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new DeleteCcaiProjectResponse();\n    DeleteCcaiProjectResponse.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: DeleteCcaiProjectResponse) {\n    _instance.name = _instance.name || '';\n    _instance.errorMessage = _instance.errorMessage || '';\n    _instance.nluProjectName = _instance.nluProjectName || '';\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: DeleteCcaiProjectResponse,\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.errorMessage = _reader.readString();\n          break;\n        case 4:\n          _instance.nluProjectName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    DeleteCcaiProjectResponse.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: DeleteCcaiProjectResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.errorMessage) {\n      _writer.writeString(2, _instance.errorMessage);\n    }\n    if (_instance.nluProjectName) {\n      _writer.writeString(4, _instance.nluProjectName);\n    }\n  }\n\n  private _name: string;\n  private _errorMessage: string;\n  private _nluProjectName: 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 DeleteCcaiProjectResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<DeleteCcaiProjectResponse.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.errorMessage = _value.errorMessage;\n    this.nluProjectName = _value.nluProjectName;\n    DeleteCcaiProjectResponse.refineValues(this);\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get errorMessage(): string {\n    return this._errorMessage;\n  }\n  set errorMessage(value: string) {\n    this._errorMessage = value;\n  }\n  get nluProjectName(): string {\n    return this._nluProjectName;\n  }\n  set nluProjectName(value: string) {\n    this._nluProjectName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    DeleteCcaiProjectResponse.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(): DeleteCcaiProjectResponse.AsObject {\n    return {\n      name: this.name,\n      errorMessage: this.errorMessage,\n      nluProjectName: this.nluProjectName\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  ): DeleteCcaiProjectResponse.AsProtobufJSON {\n    return {\n      name: this.name,\n      errorMessage: this.errorMessage,\n      nluProjectName: this.nluProjectName\n    };\n  }\n}\nexport module DeleteCcaiProjectResponse {\n  /**\n   * Standard JavaScript object representation for DeleteCcaiProjectResponse\n   */\n  export interface AsObject {\n    name: string;\n    errorMessage: string;\n    nluProjectName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for DeleteCcaiProjectResponse\n   */\n  export interface AsProtobufJSON {\n    name: string;\n    errorMessage: string;\n    nluProjectName: string;\n  }\n}\n"]}