@ondewo/csi-client-angular 2.3.1

package/esm2020/api/ondewo/csi/conversation.pb.mjs

@@ -0,0 +1,2232 @@
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+//
+// THIS IS A GENERATED FILE
+// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST
+import { uint8ArrayToBase64 } from '@ngx-grpc/common';
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf003 from '@ngx-grpc/well-known-types';
+import * as googleRpc004 from '../../google/rpc/status.pb';
+import * as ondewoNlu006 from '../../ondewo/nlu/context.pb';
+import * as googleProtobuf010 from '@ngx-grpc/well-known-types';
+import * as ondewoNlu011 from '../../ondewo/nlu/session.pb';
+import * as ondewoT2s012 from '../../ondewo/t2s/text-to-speech.pb';
+import * as ondewoS2t013 from '../../ondewo/s2t/speech-to-text.pb';
+export var ControlStatus;
+(function (ControlStatus) {
+    ControlStatus[ControlStatus["OK"] = 0] = "OK";
+    ControlStatus[ControlStatus["EMERGENCY_STOP"] = 1] = "EMERGENCY_STOP";
+})(ControlStatus || (ControlStatus = {}));
+export var ControlMessageServiceName;
+(function (ControlMessageServiceName) {
+    ControlMessageServiceName[ControlMessageServiceName["UNKNOWNNAME"] = 0] = "UNKNOWNNAME";
+    ControlMessageServiceName[ControlMessageServiceName["ondewo_s2t"] = 1] = "ondewo_s2t";
+    ControlMessageServiceName[ControlMessageServiceName["ondewo_t2s"] = 2] = "ondewo_t2s";
+    ControlMessageServiceName[ControlMessageServiceName["ondewo_nlu"] = 3] = "ondewo_nlu";
+    ControlMessageServiceName[ControlMessageServiceName["ondewo_sip"] = 4] = "ondewo_sip";
+})(ControlMessageServiceName || (ControlMessageServiceName = {}));
+export var ControlMessageServiceMethod;
+(function (ControlMessageServiceMethod) {
+    ControlMessageServiceMethod[ControlMessageServiceMethod["UNKNOWNMETHOD"] = 0] = "UNKNOWNMETHOD";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["update_config"] = 1] = "update_config";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["undo_config"] = 2] = "undo_config";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["reset_config"] = 3] = "reset_config";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["end_call"] = 4] = "end_call";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["transfer_call"] = 5] = "transfer_call";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["play_wav_files"] = 6] = "play_wav_files";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["play_text"] = 7] = "play_text";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["mute"] = 8] = "mute";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["un_mute"] = 9] = "un_mute";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["stop_all_control_messages"] = 10] = "stop_all_control_messages";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["train_agent"] = 11] = "train_agent";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["cancel_train_agent"] = 12] = "cancel_train_agent";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["delete_session"] = 13] = "delete_session";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["delete_all_contexts"] = 14] = "delete_all_contexts";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["create_context"] = 15] = "create_context";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["update_context"] = 16] = "update_context";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["delete_context"] = 17] = "delete_context";
+    ControlMessageServiceMethod[ControlMessageServiceMethod["detect_intent"] = 18] = "detect_intent";
+})(ControlMessageServiceMethod || (ControlMessageServiceMethod = {}));
+export var ConditionType;
+(function (ConditionType) {
+    ConditionType[ConditionType["UNKNOWTYPE"] = 0] = "UNKNOWTYPE";
+    ConditionType[ConditionType["immediate"] = 1] = "immediate";
+    ConditionType[ConditionType["duration"] = 2] = "duration";
+    ConditionType[ConditionType["datetime"] = 3] = "datetime";
+    ConditionType[ConditionType["interactions"] = 4] = "interactions";
+})(ConditionType || (ConditionType = {}));
+/**
+ * Message implementation for ondewo.csi.S2sPipeline
+ */
+export class S2sPipeline {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of S2sPipeline to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.id = _value.id;
+        this.s2tPipelineId = _value.s2tPipelineId;
+        this.nluProjectId = _value.nluProjectId;
+        this.nluLanguageCode = _value.nluLanguageCode;
+        this.t2sPipelineId = _value.t2sPipelineId;
+        S2sPipeline.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new S2sPipeline();
+        S2sPipeline.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.id = _instance.id || '';
+        _instance.s2tPipelineId = _instance.s2tPipelineId || '';
+        _instance.nluProjectId = _instance.nluProjectId || '';
+        _instance.nluLanguageCode = _instance.nluLanguageCode || '';
+        _instance.t2sPipelineId = _instance.t2sPipelineId || '';
+    }
+    /**
+     * 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.id = _reader.readString();
+                    break;
+                case 2:
+                    _instance.s2tPipelineId = _reader.readString();
+                    break;
+                case 3:
+                    _instance.nluProjectId = _reader.readString();
+                    break;
+                case 4:
+                    _instance.nluLanguageCode = _reader.readString();
+                    break;
+                case 5:
+                    _instance.t2sPipelineId = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        S2sPipeline.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.id) {
+            _writer.writeString(1, _instance.id);
+        }
+        if (_instance.s2tPipelineId) {
+            _writer.writeString(2, _instance.s2tPipelineId);
+        }
+        if (_instance.nluProjectId) {
+            _writer.writeString(3, _instance.nluProjectId);
+        }
+        if (_instance.nluLanguageCode) {
+            _writer.writeString(4, _instance.nluLanguageCode);
+        }
+        if (_instance.t2sPipelineId) {
+            _writer.writeString(5, _instance.t2sPipelineId);
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get s2tPipelineId() {
+        return this._s2tPipelineId;
+    }
+    set s2tPipelineId(value) {
+        this._s2tPipelineId = value;
+    }
+    get nluProjectId() {
+        return this._nluProjectId;
+    }
+    set nluProjectId(value) {
+        this._nluProjectId = value;
+    }
+    get nluLanguageCode() {
+        return this._nluLanguageCode;
+    }
+    set nluLanguageCode(value) {
+        this._nluLanguageCode = value;
+    }
+    get t2sPipelineId() {
+        return this._t2sPipelineId;
+    }
+    set t2sPipelineId(value) {
+        this._t2sPipelineId = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        S2sPipeline.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            id: this.id,
+            s2tPipelineId: this.s2tPipelineId,
+            nluProjectId: this.nluProjectId,
+            nluLanguageCode: this.nluLanguageCode,
+            t2sPipelineId: this.t2sPipelineId
+        };
+    }
+    /**
+     * 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 {
+            id: this.id,
+            s2tPipelineId: this.s2tPipelineId,
+            nluProjectId: this.nluProjectId,
+            nluLanguageCode: this.nluLanguageCode,
+            t2sPipelineId: this.t2sPipelineId
+        };
+    }
+}
+S2sPipeline.id = 'ondewo.csi.S2sPipeline';
+/**
+ * Message implementation for ondewo.csi.S2sPipelineId
+ */
+export class S2sPipelineId {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of S2sPipelineId to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.id = _value.id;
+        S2sPipelineId.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new S2sPipelineId();
+        S2sPipelineId.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.id = _instance.id || '';
+    }
+    /**
+     * 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.id = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        S2sPipelineId.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.id) {
+            _writer.writeString(1, _instance.id);
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        S2sPipelineId.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            id: this.id
+        };
+    }
+    /**
+     * 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 {
+            id: this.id
+        };
+    }
+}
+S2sPipelineId.id = 'ondewo.csi.S2sPipelineId';
+/**
+ * Message implementation for ondewo.csi.ListS2sPipelinesRequest
+ */
+export class ListS2sPipelinesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListS2sPipelinesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        ListS2sPipelinesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListS2sPipelinesRequest();
+        ListS2sPipelinesRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) { }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListS2sPipelinesRequest.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) { }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListS2sPipelinesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {};
+    }
+    /**
+     * 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 {};
+    }
+}
+ListS2sPipelinesRequest.id = 'ondewo.csi.ListS2sPipelinesRequest';
+/**
+ * Message implementation for ondewo.csi.ListS2sPipelinesResponse
+ */
+export class ListS2sPipelinesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListS2sPipelinesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.pipelines = (_value.pipelines || []).map(m => new S2sPipeline(m));
+        ListS2sPipelinesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListS2sPipelinesResponse();
+        ListS2sPipelinesResponse.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.pipelines = _instance.pipelines || [];
+    }
+    /**
+     * 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 S2sPipeline();
+                    _reader.readMessage(messageInitializer1, S2sPipeline.deserializeBinaryFromReader);
+                    (_instance.pipelines = _instance.pipelines || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListS2sPipelinesResponse.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.pipelines && _instance.pipelines.length) {
+            _writer.writeRepeatedMessage(1, _instance.pipelines, S2sPipeline.serializeBinaryToWriter);
+        }
+    }
+    get pipelines() {
+        return this._pipelines;
+    }
+    set pipelines(value) {
+        this._pipelines = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListS2sPipelinesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            pipelines: (this.pipelines || []).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 {
+            pipelines: (this.pipelines || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+ListS2sPipelinesResponse.id = 'ondewo.csi.ListS2sPipelinesResponse';
+/**
+ * Message implementation for ondewo.csi.S2sStreamRequest
+ */
+export class S2sStreamRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of S2sStreamRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.pipelineId = _value.pipelineId;
+        this.sessionId = _value.sessionId;
+        this.audio = _value.audio;
+        this.endOfStream = _value.endOfStream;
+        this.initialIntentDisplayName = _value.initialIntentDisplayName;
+        S2sStreamRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new S2sStreamRequest();
+        S2sStreamRequest.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.pipelineId = _instance.pipelineId || '';
+        _instance.sessionId = _instance.sessionId || '';
+        _instance.audio = _instance.audio || new Uint8Array();
+        _instance.endOfStream = _instance.endOfStream || false;
+        _instance.initialIntentDisplayName =
+            _instance.initialIntentDisplayName || '';
+    }
+    /**
+     * 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.pipelineId = _reader.readString();
+                    break;
+                case 2:
+                    _instance.sessionId = _reader.readString();
+                    break;
+                case 3:
+                    _instance.audio = _reader.readBytes();
+                    break;
+                case 4:
+                    _instance.endOfStream = _reader.readBool();
+                    break;
+                case 5:
+                    _instance.initialIntentDisplayName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        S2sStreamRequest.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.pipelineId) {
+            _writer.writeString(1, _instance.pipelineId);
+        }
+        if (_instance.sessionId) {
+            _writer.writeString(2, _instance.sessionId);
+        }
+        if (_instance.audio && _instance.audio.length) {
+            _writer.writeBytes(3, _instance.audio);
+        }
+        if (_instance.endOfStream) {
+            _writer.writeBool(4, _instance.endOfStream);
+        }
+        if (_instance.initialIntentDisplayName) {
+            _writer.writeString(5, _instance.initialIntentDisplayName);
+        }
+    }
+    get pipelineId() {
+        return this._pipelineId;
+    }
+    set pipelineId(value) {
+        this._pipelineId = value;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    set sessionId(value) {
+        this._sessionId = value;
+    }
+    get audio() {
+        return this._audio;
+    }
+    set audio(value) {
+        this._audio = value;
+    }
+    get endOfStream() {
+        return this._endOfStream;
+    }
+    set endOfStream(value) {
+        this._endOfStream = value;
+    }
+    get initialIntentDisplayName() {
+        return this._initialIntentDisplayName;
+    }
+    set initialIntentDisplayName(value) {
+        this._initialIntentDisplayName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        S2sStreamRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            pipelineId: this.pipelineId,
+            sessionId: this.sessionId,
+            audio: this.audio ? this.audio.subarray(0) : new Uint8Array(),
+            endOfStream: this.endOfStream,
+            initialIntentDisplayName: this.initialIntentDisplayName
+        };
+    }
+    /**
+     * 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 {
+            pipelineId: this.pipelineId,
+            sessionId: this.sessionId,
+            audio: this.audio ? uint8ArrayToBase64(this.audio) : '',
+            endOfStream: this.endOfStream,
+            initialIntentDisplayName: this.initialIntentDisplayName
+        };
+    }
+}
+S2sStreamRequest.id = 'ondewo.csi.S2sStreamRequest';
+/**
+ * Message implementation for ondewo.csi.S2sStreamResponse
+ */
+export class S2sStreamResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of S2sStreamResponse to deeply clone from
+     */
+    constructor(_value) {
+        this._response = S2sStreamResponse.ResponseCase.none;
+        _value = _value || {};
+        this.detectIntentResponse = _value.detectIntentResponse
+            ? new ondewoNlu011.DetectIntentResponse(_value.detectIntentResponse)
+            : undefined;
+        this.synthetizeResponse = _value.synthetizeResponse
+            ? new ondewoT2s012.SynthesizeResponse(_value.synthetizeResponse)
+            : undefined;
+        this.sipTrigger = _value.sipTrigger
+            ? new SipTrigger(_value.sipTrigger)
+            : undefined;
+        S2sStreamResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new S2sStreamResponse();
+        S2sStreamResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) { }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.detectIntentResponse = new ondewoNlu011.DetectIntentResponse();
+                    _reader.readMessage(_instance.detectIntentResponse, ondewoNlu011.DetectIntentResponse.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.synthetizeResponse = new ondewoT2s012.SynthesizeResponse();
+                    _reader.readMessage(_instance.synthetizeResponse, ondewoT2s012.SynthesizeResponse.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.sipTrigger = new SipTrigger();
+                    _reader.readMessage(_instance.sipTrigger, SipTrigger.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        S2sStreamResponse.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.detectIntentResponse) {
+            _writer.writeMessage(1, _instance.detectIntentResponse, ondewoNlu011.DetectIntentResponse.serializeBinaryToWriter);
+        }
+        if (_instance.synthetizeResponse) {
+            _writer.writeMessage(2, _instance.synthetizeResponse, ondewoT2s012.SynthesizeResponse.serializeBinaryToWriter);
+        }
+        if (_instance.sipTrigger) {
+            _writer.writeMessage(3, _instance.sipTrigger, SipTrigger.serializeBinaryToWriter);
+        }
+    }
+    get detectIntentResponse() {
+        return this._detectIntentResponse;
+    }
+    set detectIntentResponse(value) {
+        if (value !== undefined && value !== null) {
+            this._synthetizeResponse = this._sipTrigger = undefined;
+            this._response = S2sStreamResponse.ResponseCase.detectIntentResponse;
+        }
+        this._detectIntentResponse = value;
+    }
+    get synthetizeResponse() {
+        return this._synthetizeResponse;
+    }
+    set synthetizeResponse(value) {
+        if (value !== undefined && value !== null) {
+            this._detectIntentResponse = this._sipTrigger = undefined;
+            this._response = S2sStreamResponse.ResponseCase.synthetizeResponse;
+        }
+        this._synthetizeResponse = value;
+    }
+    get sipTrigger() {
+        return this._sipTrigger;
+    }
+    set sipTrigger(value) {
+        if (value !== undefined && value !== null) {
+            this._detectIntentResponse = this._synthetizeResponse = undefined;
+            this._response = S2sStreamResponse.ResponseCase.sipTrigger;
+        }
+        this._sipTrigger = value;
+    }
+    get response() {
+        return this._response;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        S2sStreamResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            detectIntentResponse: this.detectIntentResponse
+                ? this.detectIntentResponse.toObject()
+                : undefined,
+            synthetizeResponse: this.synthetizeResponse
+                ? this.synthetizeResponse.toObject()
+                : undefined,
+            sipTrigger: this.sipTrigger ? this.sipTrigger.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 {
+            detectIntentResponse: this.detectIntentResponse
+                ? this.detectIntentResponse.toProtobufJSON(options)
+                : null,
+            synthetizeResponse: this.synthetizeResponse
+                ? this.synthetizeResponse.toProtobufJSON(options)
+                : null,
+            sipTrigger: this.sipTrigger
+                ? this.sipTrigger.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+S2sStreamResponse.id = 'ondewo.csi.S2sStreamResponse';
+(function (S2sStreamResponse) {
+    let ResponseCase;
+    (function (ResponseCase) {
+        ResponseCase[ResponseCase["none"] = 0] = "none";
+        ResponseCase[ResponseCase["detectIntentResponse"] = 1] = "detectIntentResponse";
+        ResponseCase[ResponseCase["synthetizeResponse"] = 2] = "synthetizeResponse";
+        ResponseCase[ResponseCase["sipTrigger"] = 3] = "sipTrigger";
+    })(ResponseCase = S2sStreamResponse.ResponseCase || (S2sStreamResponse.ResponseCase = {}));
+})(S2sStreamResponse || (S2sStreamResponse = {}));
+/**
+ * Message implementation for ondewo.csi.SipTrigger
+ */
+export class SipTrigger {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipTrigger to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.type = _value.type;
+        this.content = _value.content
+            ? new googleProtobuf003.Struct(_value.content)
+            : undefined;
+        SipTrigger.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipTrigger();
+        SipTrigger.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.type = _instance.type || 0;
+        _instance.content = _instance.content || 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.type = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.content = new googleProtobuf003.Struct();
+                    _reader.readMessage(_instance.content, googleProtobuf003.Struct.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipTrigger.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.type) {
+            _writer.writeEnum(1, _instance.type);
+        }
+        if (_instance.content) {
+            _writer.writeMessage(2, _instance.content, googleProtobuf003.Struct.serializeBinaryToWriter);
+        }
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+    get content() {
+        return this._content;
+    }
+    set content(value) {
+        this._content = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipTrigger.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            type: this.type,
+            content: this.content ? this.content.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 {
+            type: SipTrigger.SipTriggerType[this.type === null || this.type === undefined ? 0 : this.type],
+            content: this.content ? this.content.toProtobufJSON(options) : null
+        };
+    }
+}
+SipTrigger.id = 'ondewo.csi.SipTrigger';
+(function (SipTrigger) {
+    let SipTriggerType;
+    (function (SipTriggerType) {
+        SipTriggerType[SipTriggerType["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+        SipTriggerType[SipTriggerType["HANGUP"] = 1] = "HANGUP";
+        SipTriggerType[SipTriggerType["HUMAN_HANDOVER"] = 2] = "HUMAN_HANDOVER";
+        SipTriggerType[SipTriggerType["SEND_NOW"] = 3] = "SEND_NOW";
+        SipTriggerType[SipTriggerType["PAUSE"] = 4] = "PAUSE";
+    })(SipTriggerType = SipTrigger.SipTriggerType || (SipTrigger.SipTriggerType = {}));
+})(SipTrigger || (SipTrigger = {}));
+/**
+ * Message implementation for ondewo.csi.CheckUpstreamHealthResponse
+ */
+export class CheckUpstreamHealthResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CheckUpstreamHealthResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.s2tStatus = _value.s2tStatus
+            ? new googleRpc004.Status(_value.s2tStatus)
+            : undefined;
+        this.nluStatus = _value.nluStatus
+            ? new googleRpc004.Status(_value.nluStatus)
+            : undefined;
+        this.t2sStatus = _value.t2sStatus
+            ? new googleRpc004.Status(_value.t2sStatus)
+            : undefined;
+        CheckUpstreamHealthResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CheckUpstreamHealthResponse();
+        CheckUpstreamHealthResponse.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.s2tStatus = _instance.s2tStatus || undefined;
+        _instance.nluStatus = _instance.nluStatus || undefined;
+        _instance.t2sStatus = _instance.t2sStatus || 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.s2tStatus = new googleRpc004.Status();
+                    _reader.readMessage(_instance.s2tStatus, googleRpc004.Status.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.nluStatus = new googleRpc004.Status();
+                    _reader.readMessage(_instance.nluStatus, googleRpc004.Status.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.t2sStatus = new googleRpc004.Status();
+                    _reader.readMessage(_instance.t2sStatus, googleRpc004.Status.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CheckUpstreamHealthResponse.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.s2tStatus) {
+            _writer.writeMessage(1, _instance.s2tStatus, googleRpc004.Status.serializeBinaryToWriter);
+        }
+        if (_instance.nluStatus) {
+            _writer.writeMessage(2, _instance.nluStatus, googleRpc004.Status.serializeBinaryToWriter);
+        }
+        if (_instance.t2sStatus) {
+            _writer.writeMessage(3, _instance.t2sStatus, googleRpc004.Status.serializeBinaryToWriter);
+        }
+    }
+    get s2tStatus() {
+        return this._s2tStatus;
+    }
+    set s2tStatus(value) {
+        this._s2tStatus = value;
+    }
+    get nluStatus() {
+        return this._nluStatus;
+    }
+    set nluStatus(value) {
+        this._nluStatus = value;
+    }
+    get t2sStatus() {
+        return this._t2sStatus;
+    }
+    set t2sStatus(value) {
+        this._t2sStatus = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CheckUpstreamHealthResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            s2tStatus: this.s2tStatus ? this.s2tStatus.toObject() : undefined,
+            nluStatus: this.nluStatus ? this.nluStatus.toObject() : undefined,
+            t2sStatus: this.t2sStatus ? this.t2sStatus.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 {
+            s2tStatus: this.s2tStatus ? this.s2tStatus.toProtobufJSON(options) : null,
+            nluStatus: this.nluStatus ? this.nluStatus.toProtobufJSON(options) : null,
+            t2sStatus: this.t2sStatus ? this.t2sStatus.toProtobufJSON(options) : null
+        };
+    }
+}
+CheckUpstreamHealthResponse.id = 'ondewo.csi.CheckUpstreamHealthResponse';
+/**
+ * Message implementation for ondewo.csi.ControlStreamRequest
+ */
+export class ControlStreamRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ControlStreamRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        ControlStreamRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ControlStreamRequest();
+        ControlStreamRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) { }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                default:
+                    _reader.skipField();
+            }
+        }
+        ControlStreamRequest.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) { }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ControlStreamRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {};
+    }
+    /**
+     * 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 {};
+    }
+}
+ControlStreamRequest.id = 'ondewo.csi.ControlStreamRequest';
+/**
+ * Message implementation for ondewo.csi.ControlStreamResponse
+ */
+export class ControlStreamResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ControlStreamResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.controlStatus = _value.controlStatus;
+        ControlStreamResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ControlStreamResponse();
+        ControlStreamResponse.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.controlStatus = _instance.controlStatus || 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.controlStatus = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ControlStreamResponse.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.controlStatus) {
+            _writer.writeEnum(1, _instance.controlStatus);
+        }
+    }
+    get controlStatus() {
+        return this._controlStatus;
+    }
+    set controlStatus(value) {
+        this._controlStatus = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ControlStreamResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            controlStatus: this.controlStatus
+        };
+    }
+    /**
+     * 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 {
+            controlStatus: ControlStatus[this.controlStatus === null || this.controlStatus === undefined
+                ? 0
+                : this.controlStatus]
+        };
+    }
+}
+ControlStreamResponse.id = 'ondewo.csi.ControlStreamResponse';
+/**
+ * Message implementation for ondewo.csi.SetControlStatusRequest
+ */
+export class SetControlStatusRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SetControlStatusRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.controlStatus = _value.controlStatus;
+        SetControlStatusRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SetControlStatusRequest();
+        SetControlStatusRequest.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.controlStatus = _instance.controlStatus || 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.controlStatus = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SetControlStatusRequest.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.controlStatus) {
+            _writer.writeEnum(1, _instance.controlStatus);
+        }
+    }
+    get controlStatus() {
+        return this._controlStatus;
+    }
+    set controlStatus(value) {
+        this._controlStatus = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SetControlStatusRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            controlStatus: this.controlStatus
+        };
+    }
+    /**
+     * 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 {
+            controlStatus: ControlStatus[this.controlStatus === null || this.controlStatus === undefined
+                ? 0
+                : this.controlStatus]
+        };
+    }
+}
+SetControlStatusRequest.id = 'ondewo.csi.SetControlStatusRequest';
+/**
+ * Message implementation for ondewo.csi.SetControlStatusResponse
+ */
+export class SetControlStatusResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SetControlStatusResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.oldControlStatus = _value.oldControlStatus;
+        this.newControlStatus = _value.newControlStatus;
+        SetControlStatusResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SetControlStatusResponse();
+        SetControlStatusResponse.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.oldControlStatus = _instance.oldControlStatus || 0;
+        _instance.newControlStatus = _instance.newControlStatus || 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.oldControlStatus = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.newControlStatus = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SetControlStatusResponse.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.oldControlStatus) {
+            _writer.writeEnum(1, _instance.oldControlStatus);
+        }
+        if (_instance.newControlStatus) {
+            _writer.writeEnum(2, _instance.newControlStatus);
+        }
+    }
+    get oldControlStatus() {
+        return this._oldControlStatus;
+    }
+    set oldControlStatus(value) {
+        this._oldControlStatus = value;
+    }
+    get newControlStatus() {
+        return this._newControlStatus;
+    }
+    set newControlStatus(value) {
+        this._newControlStatus = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SetControlStatusResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            oldControlStatus: this.oldControlStatus,
+            newControlStatus: this.newControlStatus
+        };
+    }
+    /**
+     * 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 {
+            oldControlStatus: ControlStatus[this.oldControlStatus === null || this.oldControlStatus === undefined
+                ? 0
+                : this.oldControlStatus],
+            newControlStatus: ControlStatus[this.newControlStatus === null || this.newControlStatus === undefined
+                ? 0
+                : this.newControlStatus]
+        };
+    }
+}
+SetControlStatusResponse.id = 'ondewo.csi.SetControlStatusResponse';
+/**
+ * Message implementation for ondewo.csi.CondtionValueUnion
+ */
+export class CondtionValueUnion {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CondtionValueUnion to deeply clone from
+     */
+    constructor(_value) {
+        this._unionOneof = CondtionValueUnion.UnionOneofCase.none;
+        _value = _value || {};
+        this.intValue = _value.intValue;
+        this.floatValue = _value.floatValue;
+        this.datetimeValue = _value.datetimeValue
+            ? new googleProtobuf010.Timestamp(_value.datetimeValue)
+            : undefined;
+        CondtionValueUnion.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CondtionValueUnion();
+        CondtionValueUnion.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) { }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.intValue = _reader.readInt64String();
+                    break;
+                case 2:
+                    _instance.floatValue = _reader.readFloat();
+                    break;
+                case 3:
+                    _instance.datetimeValue = new googleProtobuf010.Timestamp();
+                    _reader.readMessage(_instance.datetimeValue, googleProtobuf010.Timestamp.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CondtionValueUnion.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.intValue || _instance.intValue === '0') {
+            _writer.writeInt64String(1, _instance.intValue);
+        }
+        if (_instance.floatValue || _instance.floatValue === 0) {
+            _writer.writeFloat(2, _instance.floatValue);
+        }
+        if (_instance.datetimeValue) {
+            _writer.writeMessage(3, _instance.datetimeValue, googleProtobuf010.Timestamp.serializeBinaryToWriter);
+        }
+    }
+    get intValue() {
+        return this._intValue;
+    }
+    set intValue(value) {
+        if (value !== undefined && value !== null) {
+            this._floatValue = this._datetimeValue = undefined;
+            this._unionOneof = CondtionValueUnion.UnionOneofCase.intValue;
+        }
+        this._intValue = value;
+    }
+    get floatValue() {
+        return this._floatValue;
+    }
+    set floatValue(value) {
+        if (value !== undefined && value !== null) {
+            this._intValue = this._datetimeValue = undefined;
+            this._unionOneof = CondtionValueUnion.UnionOneofCase.floatValue;
+        }
+        this._floatValue = value;
+    }
+    get datetimeValue() {
+        return this._datetimeValue;
+    }
+    set datetimeValue(value) {
+        if (value !== undefined && value !== null) {
+            this._intValue = this._floatValue = undefined;
+            this._unionOneof = CondtionValueUnion.UnionOneofCase.datetimeValue;
+        }
+        this._datetimeValue = value;
+    }
+    get unionOneof() {
+        return this._unionOneof;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CondtionValueUnion.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            intValue: this.intValue,
+            floatValue: this.floatValue,
+            datetimeValue: this.datetimeValue
+                ? this.datetimeValue.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 {
+            intValue: this.intValue === null || this.intValue === undefined
+                ? null
+                : this.intValue,
+            floatValue: this.floatValue === null || this.floatValue === undefined
+                ? null
+                : this.floatValue,
+            datetimeValue: this.datetimeValue
+                ? this.datetimeValue.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+CondtionValueUnion.id = 'ondewo.csi.CondtionValueUnion';
+(function (CondtionValueUnion) {
+    let UnionOneofCase;
+    (function (UnionOneofCase) {
+        UnionOneofCase[UnionOneofCase["none"] = 0] = "none";
+        UnionOneofCase[UnionOneofCase["intValue"] = 1] = "intValue";
+        UnionOneofCase[UnionOneofCase["floatValue"] = 2] = "floatValue";
+        UnionOneofCase[UnionOneofCase["datetimeValue"] = 3] = "datetimeValue";
+    })(UnionOneofCase = CondtionValueUnion.UnionOneofCase || (CondtionValueUnion.UnionOneofCase = {}));
+})(CondtionValueUnion || (CondtionValueUnion = {}));
+/**
+ * Message implementation for ondewo.csi.Condition
+ */
+export class Condition {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Condition to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.type = _value.type;
+        this.value = _value.value;
+        Condition.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Condition();
+        Condition.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.type = _instance.type || 0;
+        _instance.value = _instance.value || '';
+    }
+    /**
+     * 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.type = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.value = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Condition.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.type) {
+            _writer.writeEnum(1, _instance.type);
+        }
+        if (_instance.value) {
+            _writer.writeString(2, _instance.value);
+        }
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = 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();
+        Condition.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            type: this.type,
+            value: this.value
+        };
+    }
+    /**
+     * 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 {
+            type: ConditionType[this.type === null || this.type === undefined ? 0 : this.type],
+            value: this.value
+        };
+    }
+}
+Condition.id = 'ondewo.csi.Condition';
+/**
+ * Message implementation for ondewo.csi.ControlMessageServiceParameters
+ */
+export class ControlMessageServiceParameters {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ControlMessageServiceParameters to deeply clone from
+     */
+    constructor(_value) {
+        this._config = ControlMessageServiceParameters.ConfigCase.none;
+        _value = _value || {};
+        this.t2sConfig = _value.t2sConfig
+            ? new ondewoT2s012.RequestConfig(_value.t2sConfig)
+            : undefined;
+        this.s2tConfig = _value.s2tConfig
+            ? new ondewoS2t013.TranscribeRequestConfig(_value.s2tConfig)
+            : undefined;
+        this.transferId = _value.transferId;
+        this.wavFiles = (_value.wavFiles || []).map(b => b ? b.subarray(0) : new Uint8Array());
+        this.text = _value.text;
+        this.context = _value.context
+            ? new ondewoNlu006.Context(_value.context)
+            : undefined;
+        this.sessionId = _value.sessionId;
+        this.contextName = _value.contextName;
+        this.conditionStart = _value.conditionStart
+            ? new Condition(_value.conditionStart)
+            : undefined;
+        this.conditionEnd = _value.conditionEnd
+            ? new Condition(_value.conditionEnd)
+            : undefined;
+        ControlMessageServiceParameters.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ControlMessageServiceParameters();
+        ControlMessageServiceParameters.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.transferId = _instance.transferId || '';
+        _instance.wavFiles = _instance.wavFiles || [];
+        _instance.text = _instance.text || '';
+        _instance.context = _instance.context || undefined;
+        _instance.sessionId = _instance.sessionId || '';
+        _instance.contextName = _instance.contextName || '';
+        _instance.conditionStart = _instance.conditionStart || undefined;
+        _instance.conditionEnd = _instance.conditionEnd || 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.t2sConfig = new ondewoT2s012.RequestConfig();
+                    _reader.readMessage(_instance.t2sConfig, ondewoT2s012.RequestConfig.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.s2tConfig = new ondewoS2t013.TranscribeRequestConfig();
+                    _reader.readMessage(_instance.s2tConfig, ondewoS2t013.TranscribeRequestConfig.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.transferId = _reader.readString();
+                    break;
+                case 4:
+                    (_instance.wavFiles = _instance.wavFiles || []).push(_reader.readBytes());
+                    break;
+                case 5:
+                    _instance.text = _reader.readString();
+                    break;
+                case 6:
+                    _instance.context = new ondewoNlu006.Context();
+                    _reader.readMessage(_instance.context, ondewoNlu006.Context.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.sessionId = _reader.readString();
+                    break;
+                case 8:
+                    _instance.contextName = _reader.readString();
+                    break;
+                case 9:
+                    _instance.conditionStart = new Condition();
+                    _reader.readMessage(_instance.conditionStart, Condition.deserializeBinaryFromReader);
+                    break;
+                case 10:
+                    _instance.conditionEnd = new Condition();
+                    _reader.readMessage(_instance.conditionEnd, Condition.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ControlMessageServiceParameters.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.t2sConfig) {
+            _writer.writeMessage(1, _instance.t2sConfig, ondewoT2s012.RequestConfig.serializeBinaryToWriter);
+        }
+        if (_instance.s2tConfig) {
+            _writer.writeMessage(2, _instance.s2tConfig, ondewoS2t013.TranscribeRequestConfig.serializeBinaryToWriter);
+        }
+        if (_instance.transferId) {
+            _writer.writeString(3, _instance.transferId);
+        }
+        if (_instance.wavFiles && _instance.wavFiles.length) {
+            _writer.writeRepeatedBytes(4, _instance.wavFiles);
+        }
+        if (_instance.text) {
+            _writer.writeString(5, _instance.text);
+        }
+        if (_instance.context) {
+            _writer.writeMessage(6, _instance.context, ondewoNlu006.Context.serializeBinaryToWriter);
+        }
+        if (_instance.sessionId) {
+            _writer.writeString(7, _instance.sessionId);
+        }
+        if (_instance.contextName) {
+            _writer.writeString(8, _instance.contextName);
+        }
+        if (_instance.conditionStart) {
+            _writer.writeMessage(9, _instance.conditionStart, Condition.serializeBinaryToWriter);
+        }
+        if (_instance.conditionEnd) {
+            _writer.writeMessage(10, _instance.conditionEnd, Condition.serializeBinaryToWriter);
+        }
+    }
+    get t2sConfig() {
+        return this._t2sConfig;
+    }
+    set t2sConfig(value) {
+        if (value !== undefined && value !== null) {
+            this._s2tConfig = undefined;
+            this._config = ControlMessageServiceParameters.ConfigCase.t2sConfig;
+        }
+        this._t2sConfig = value;
+    }
+    get s2tConfig() {
+        return this._s2tConfig;
+    }
+    set s2tConfig(value) {
+        if (value !== undefined && value !== null) {
+            this._t2sConfig = undefined;
+            this._config = ControlMessageServiceParameters.ConfigCase.s2tConfig;
+        }
+        this._s2tConfig = value;
+    }
+    get transferId() {
+        return this._transferId;
+    }
+    set transferId(value) {
+        this._transferId = value;
+    }
+    get wavFiles() {
+        return this._wavFiles;
+    }
+    set wavFiles(value) {
+        this._wavFiles = value;
+    }
+    get text() {
+        return this._text;
+    }
+    set text(value) {
+        this._text = value;
+    }
+    get context() {
+        return this._context;
+    }
+    set context(value) {
+        this._context = value;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    set sessionId(value) {
+        this._sessionId = value;
+    }
+    get contextName() {
+        return this._contextName;
+    }
+    set contextName(value) {
+        this._contextName = value;
+    }
+    get conditionStart() {
+        return this._conditionStart;
+    }
+    set conditionStart(value) {
+        this._conditionStart = value;
+    }
+    get conditionEnd() {
+        return this._conditionEnd;
+    }
+    set conditionEnd(value) {
+        this._conditionEnd = value;
+    }
+    get config() {
+        return this._config;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ControlMessageServiceParameters.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            t2sConfig: this.t2sConfig ? this.t2sConfig.toObject() : undefined,
+            s2tConfig: this.s2tConfig ? this.s2tConfig.toObject() : undefined,
+            transferId: this.transferId,
+            wavFiles: (this.wavFiles || []).map(b => b ? b.subarray(0) : new Uint8Array()),
+            text: this.text,
+            context: this.context ? this.context.toObject() : undefined,
+            sessionId: this.sessionId,
+            contextName: this.contextName,
+            conditionStart: this.conditionStart
+                ? this.conditionStart.toObject()
+                : undefined,
+            conditionEnd: this.conditionEnd ? this.conditionEnd.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 {
+            t2sConfig: this.t2sConfig ? this.t2sConfig.toProtobufJSON(options) : null,
+            s2tConfig: this.s2tConfig ? this.s2tConfig.toProtobufJSON(options) : null,
+            transferId: this.transferId,
+            wavFiles: (this.wavFiles || []).map(b => b ? uint8ArrayToBase64(b) : ''),
+            text: this.text,
+            context: this.context ? this.context.toProtobufJSON(options) : null,
+            sessionId: this.sessionId,
+            contextName: this.contextName,
+            conditionStart: this.conditionStart
+                ? this.conditionStart.toProtobufJSON(options)
+                : null,
+            conditionEnd: this.conditionEnd
+                ? this.conditionEnd.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+ControlMessageServiceParameters.id = 'ondewo.csi.ControlMessageServiceParameters';
+(function (ControlMessageServiceParameters) {
+    let ConfigCase;
+    (function (ConfigCase) {
+        ConfigCase[ConfigCase["none"] = 0] = "none";
+        ConfigCase[ConfigCase["t2sConfig"] = 1] = "t2sConfig";
+        ConfigCase[ConfigCase["s2tConfig"] = 2] = "s2tConfig";
+    })(ConfigCase = ControlMessageServiceParameters.ConfigCase || (ControlMessageServiceParameters.ConfigCase = {}));
+})(ControlMessageServiceParameters || (ControlMessageServiceParameters = {}));
+/**
+ * Message implementation for ondewo.csi.ControlMessage
+ */
+export class ControlMessage {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ControlMessage to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.service = _value.service;
+        this.method = _value.method;
+        this.parameters = _value.parameters
+            ? new ControlMessageServiceParameters(_value.parameters)
+            : undefined;
+        ControlMessage.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ControlMessage();
+        ControlMessage.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.service = _instance.service || 0;
+        _instance.method = _instance.method || 0;
+        _instance.parameters = _instance.parameters || 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.service = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.method = _reader.readEnum();
+                    break;
+                case 3:
+                    _instance.parameters = new ControlMessageServiceParameters();
+                    _reader.readMessage(_instance.parameters, ControlMessageServiceParameters.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ControlMessage.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.service) {
+            _writer.writeEnum(1, _instance.service);
+        }
+        if (_instance.method) {
+            _writer.writeEnum(2, _instance.method);
+        }
+        if (_instance.parameters) {
+            _writer.writeMessage(3, _instance.parameters, ControlMessageServiceParameters.serializeBinaryToWriter);
+        }
+    }
+    get service() {
+        return this._service;
+    }
+    set service(value) {
+        this._service = value;
+    }
+    get method() {
+        return this._method;
+    }
+    set method(value) {
+        this._method = value;
+    }
+    get parameters() {
+        return this._parameters;
+    }
+    set parameters(value) {
+        this._parameters = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ControlMessage.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            service: this.service,
+            method: this.method,
+            parameters: this.parameters ? this.parameters.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 {
+            service: ControlMessageServiceName[this.service === null || this.service === undefined ? 0 : this.service],
+            method: ControlMessageServiceMethod[this.method === null || this.method === undefined ? 0 : this.method],
+            parameters: this.parameters
+                ? this.parameters.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+ControlMessage.id = 'ondewo.csi.ControlMessage';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conversation.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/csi/conversation.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  uint8ArrayToBase64\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleProtobuf000 from '@ngx-grpc/well-known-types';\nimport * as googleApi001 from '../../google/api/annotations.pb';\nimport * as googleProtobuf002 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf003 from '@ngx-grpc/well-known-types';\nimport * as googleRpc004 from '../../google/rpc/status.pb';\nimport * as googleType005 from '../../google/type/latlng.pb';\nimport * as ondewoNlu006 from '../../ondewo/nlu/context.pb';\nimport * as ondewoNlu007 from '../../ondewo/nlu/intent.pb';\nimport * as ondewoNlu008 from '../../ondewo/nlu/entity-type.pb';\nimport * as googleProtobuf009 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf010 from '@ngx-grpc/well-known-types';\nimport * as ondewoNlu011 from '../../ondewo/nlu/session.pb';\nimport * as ondewoT2s012 from '../../ondewo/t2s/text-to-speech.pb';\nimport * as ondewoS2t013 from '../../ondewo/s2t/speech-to-text.pb';\nexport enum ControlStatus {\n  OK = 0,\n  EMERGENCY_STOP = 1\n}\nexport enum ControlMessageServiceName {\n  UNKNOWNNAME = 0,\n  ondewo_s2t = 1,\n  ondewo_t2s = 2,\n  ondewo_nlu = 3,\n  ondewo_sip = 4\n}\nexport enum ControlMessageServiceMethod {\n  UNKNOWNMETHOD = 0,\n  update_config = 1,\n  undo_config = 2,\n  reset_config = 3,\n  end_call = 4,\n  transfer_call = 5,\n  play_wav_files = 6,\n  play_text = 7,\n  mute = 8,\n  un_mute = 9,\n  stop_all_control_messages = 10,\n  train_agent = 11,\n  cancel_train_agent = 12,\n  delete_session = 13,\n  delete_all_contexts = 14,\n  create_context = 15,\n  update_context = 16,\n  delete_context = 17,\n  detect_intent = 18\n}\nexport enum ConditionType {\n  UNKNOWTYPE = 0,\n  immediate = 1,\n  duration = 2,\n  datetime = 3,\n  interactions = 4\n}\n/**\n * Message implementation for ondewo.csi.S2sPipeline\n */\nexport class S2sPipeline implements GrpcMessage {\n  static id = 'ondewo.csi.S2sPipeline';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new S2sPipeline();\n    S2sPipeline.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: S2sPipeline) {\n    _instance.id = _instance.id || '';\n    _instance.s2tPipelineId = _instance.s2tPipelineId || '';\n    _instance.nluProjectId = _instance.nluProjectId || '';\n    _instance.nluLanguageCode = _instance.nluLanguageCode || '';\n    _instance.t2sPipelineId = _instance.t2sPipelineId || '';\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: S2sPipeline,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.id = _reader.readString();\n          break;\n        case 2:\n          _instance.s2tPipelineId = _reader.readString();\n          break;\n        case 3:\n          _instance.nluProjectId = _reader.readString();\n          break;\n        case 4:\n          _instance.nluLanguageCode = _reader.readString();\n          break;\n        case 5:\n          _instance.t2sPipelineId = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    S2sPipeline.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: S2sPipeline,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.id) {\n      _writer.writeString(1, _instance.id);\n    }\n    if (_instance.s2tPipelineId) {\n      _writer.writeString(2, _instance.s2tPipelineId);\n    }\n    if (_instance.nluProjectId) {\n      _writer.writeString(3, _instance.nluProjectId);\n    }\n    if (_instance.nluLanguageCode) {\n      _writer.writeString(4, _instance.nluLanguageCode);\n    }\n    if (_instance.t2sPipelineId) {\n      _writer.writeString(5, _instance.t2sPipelineId);\n    }\n  }\n\n  private _id?: string;\n  private _s2tPipelineId?: string;\n  private _nluProjectId?: string;\n  private _nluLanguageCode?: string;\n  private _t2sPipelineId?: 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 S2sPipeline to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<S2sPipeline.AsObject>) {\n    _value = _value || {};\n    this.id = _value.id;\n    this.s2tPipelineId = _value.s2tPipelineId;\n    this.nluProjectId = _value.nluProjectId;\n    this.nluLanguageCode = _value.nluLanguageCode;\n    this.t2sPipelineId = _value.t2sPipelineId;\n    S2sPipeline.refineValues(this);\n  }\n  get id(): string | undefined {\n    return this._id;\n  }\n  set id(value: string | undefined) {\n    this._id = value;\n  }\n  get s2tPipelineId(): string | undefined {\n    return this._s2tPipelineId;\n  }\n  set s2tPipelineId(value: string | undefined) {\n    this._s2tPipelineId = value;\n  }\n  get nluProjectId(): string | undefined {\n    return this._nluProjectId;\n  }\n  set nluProjectId(value: string | undefined) {\n    this._nluProjectId = value;\n  }\n  get nluLanguageCode(): string | undefined {\n    return this._nluLanguageCode;\n  }\n  set nluLanguageCode(value: string | undefined) {\n    this._nluLanguageCode = value;\n  }\n  get t2sPipelineId(): string | undefined {\n    return this._t2sPipelineId;\n  }\n  set t2sPipelineId(value: string | undefined) {\n    this._t2sPipelineId = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    S2sPipeline.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(): S2sPipeline.AsObject {\n    return {\n      id: this.id,\n      s2tPipelineId: this.s2tPipelineId,\n      nluProjectId: this.nluProjectId,\n      nluLanguageCode: this.nluLanguageCode,\n      t2sPipelineId: this.t2sPipelineId\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  ): S2sPipeline.AsProtobufJSON {\n    return {\n      id: this.id,\n      s2tPipelineId: this.s2tPipelineId,\n      nluProjectId: this.nluProjectId,\n      nluLanguageCode: this.nluLanguageCode,\n      t2sPipelineId: this.t2sPipelineId\n    };\n  }\n}\nexport module S2sPipeline {\n  /**\n   * Standard JavaScript object representation for S2sPipeline\n   */\n  export interface AsObject {\n    id?: string;\n    s2tPipelineId?: string;\n    nluProjectId?: string;\n    nluLanguageCode?: string;\n    t2sPipelineId?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for S2sPipeline\n   */\n  export interface AsProtobufJSON {\n    id?: string;\n    s2tPipelineId?: string;\n    nluProjectId?: string;\n    nluLanguageCode?: string;\n    t2sPipelineId?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.S2sPipelineId\n */\nexport class S2sPipelineId implements GrpcMessage {\n  static id = 'ondewo.csi.S2sPipelineId';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new S2sPipelineId();\n    S2sPipelineId.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: S2sPipelineId) {\n    _instance.id = _instance.id || '';\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: S2sPipelineId,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.id = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    S2sPipelineId.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: S2sPipelineId,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.id) {\n      _writer.writeString(1, _instance.id);\n    }\n  }\n\n  private _id?: 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 S2sPipelineId to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<S2sPipelineId.AsObject>) {\n    _value = _value || {};\n    this.id = _value.id;\n    S2sPipelineId.refineValues(this);\n  }\n  get id(): string | undefined {\n    return this._id;\n  }\n  set id(value: string | undefined) {\n    this._id = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    S2sPipelineId.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(): S2sPipelineId.AsObject {\n    return {\n      id: this.id\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  ): S2sPipelineId.AsProtobufJSON {\n    return {\n      id: this.id\n    };\n  }\n}\nexport module S2sPipelineId {\n  /**\n   * Standard JavaScript object representation for S2sPipelineId\n   */\n  export interface AsObject {\n    id?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for S2sPipelineId\n   */\n  export interface AsProtobufJSON {\n    id?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.ListS2sPipelinesRequest\n */\nexport class ListS2sPipelinesRequest implements GrpcMessage {\n  static id = 'ondewo.csi.ListS2sPipelinesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListS2sPipelinesRequest();\n    ListS2sPipelinesRequest.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: ListS2sPipelinesRequest) {}\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: ListS2sPipelinesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListS2sPipelinesRequest.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: ListS2sPipelinesRequest,\n    _writer: BinaryWriter\n  ) {}\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListS2sPipelinesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListS2sPipelinesRequest.AsObject>) {\n    _value = _value || {};\n    ListS2sPipelinesRequest.refineValues(this);\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListS2sPipelinesRequest.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(): ListS2sPipelinesRequest.AsObject {\n    return {};\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  ): ListS2sPipelinesRequest.AsProtobufJSON {\n    return {};\n  }\n}\nexport module ListS2sPipelinesRequest {\n  /**\n   * Standard JavaScript object representation for ListS2sPipelinesRequest\n   */\n  export interface AsObject {}\n\n  /**\n   * Protobuf JSON representation for ListS2sPipelinesRequest\n   */\n  export interface AsProtobufJSON {}\n}\n\n/**\n * Message implementation for ondewo.csi.ListS2sPipelinesResponse\n */\nexport class ListS2sPipelinesResponse implements GrpcMessage {\n  static id = 'ondewo.csi.ListS2sPipelinesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListS2sPipelinesResponse();\n    ListS2sPipelinesResponse.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: ListS2sPipelinesResponse) {\n    _instance.pipelines = _instance.pipelines || [];\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: ListS2sPipelinesResponse,\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 S2sPipeline();\n          _reader.readMessage(\n            messageInitializer1,\n            S2sPipeline.deserializeBinaryFromReader\n          );\n          (_instance.pipelines = _instance.pipelines || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListS2sPipelinesResponse.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: ListS2sPipelinesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.pipelines && _instance.pipelines.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.pipelines as any,\n        S2sPipeline.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _pipelines?: S2sPipeline[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListS2sPipelinesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListS2sPipelinesResponse.AsObject>) {\n    _value = _value || {};\n    this.pipelines = (_value.pipelines || []).map(m => new S2sPipeline(m));\n    ListS2sPipelinesResponse.refineValues(this);\n  }\n  get pipelines(): S2sPipeline[] | undefined {\n    return this._pipelines;\n  }\n  set pipelines(value: S2sPipeline[] | undefined) {\n    this._pipelines = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListS2sPipelinesResponse.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(): ListS2sPipelinesResponse.AsObject {\n    return {\n      pipelines: (this.pipelines || []).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  ): ListS2sPipelinesResponse.AsProtobufJSON {\n    return {\n      pipelines: (this.pipelines || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module ListS2sPipelinesResponse {\n  /**\n   * Standard JavaScript object representation for ListS2sPipelinesResponse\n   */\n  export interface AsObject {\n    pipelines?: S2sPipeline.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for ListS2sPipelinesResponse\n   */\n  export interface AsProtobufJSON {\n    pipelines?: S2sPipeline.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.S2sStreamRequest\n */\nexport class S2sStreamRequest implements GrpcMessage {\n  static id = 'ondewo.csi.S2sStreamRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new S2sStreamRequest();\n    S2sStreamRequest.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: S2sStreamRequest) {\n    _instance.pipelineId = _instance.pipelineId || '';\n    _instance.sessionId = _instance.sessionId || '';\n    _instance.audio = _instance.audio || new Uint8Array();\n    _instance.endOfStream = _instance.endOfStream || false;\n    _instance.initialIntentDisplayName =\n      _instance.initialIntentDisplayName || '';\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: S2sStreamRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.pipelineId = _reader.readString();\n          break;\n        case 2:\n          _instance.sessionId = _reader.readString();\n          break;\n        case 3:\n          _instance.audio = _reader.readBytes();\n          break;\n        case 4:\n          _instance.endOfStream = _reader.readBool();\n          break;\n        case 5:\n          _instance.initialIntentDisplayName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    S2sStreamRequest.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: S2sStreamRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.pipelineId) {\n      _writer.writeString(1, _instance.pipelineId);\n    }\n    if (_instance.sessionId) {\n      _writer.writeString(2, _instance.sessionId);\n    }\n    if (_instance.audio && _instance.audio.length) {\n      _writer.writeBytes(3, _instance.audio);\n    }\n    if (_instance.endOfStream) {\n      _writer.writeBool(4, _instance.endOfStream);\n    }\n    if (_instance.initialIntentDisplayName) {\n      _writer.writeString(5, _instance.initialIntentDisplayName);\n    }\n  }\n\n  private _pipelineId?: string;\n  private _sessionId?: string;\n  private _audio?: Uint8Array;\n  private _endOfStream?: boolean;\n  private _initialIntentDisplayName?: 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 S2sStreamRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<S2sStreamRequest.AsObject>) {\n    _value = _value || {};\n    this.pipelineId = _value.pipelineId;\n    this.sessionId = _value.sessionId;\n    this.audio = _value.audio;\n    this.endOfStream = _value.endOfStream;\n    this.initialIntentDisplayName = _value.initialIntentDisplayName;\n    S2sStreamRequest.refineValues(this);\n  }\n  get pipelineId(): string | undefined {\n    return this._pipelineId;\n  }\n  set pipelineId(value: string | undefined) {\n    this._pipelineId = value;\n  }\n  get sessionId(): string | undefined {\n    return this._sessionId;\n  }\n  set sessionId(value: string | undefined) {\n    this._sessionId = value;\n  }\n  get audio(): Uint8Array | undefined {\n    return this._audio;\n  }\n  set audio(value: Uint8Array | undefined) {\n    this._audio = value;\n  }\n  get endOfStream(): boolean | undefined {\n    return this._endOfStream;\n  }\n  set endOfStream(value: boolean | undefined) {\n    this._endOfStream = value;\n  }\n  get initialIntentDisplayName(): string | undefined {\n    return this._initialIntentDisplayName;\n  }\n  set initialIntentDisplayName(value: string | undefined) {\n    this._initialIntentDisplayName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    S2sStreamRequest.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(): S2sStreamRequest.AsObject {\n    return {\n      pipelineId: this.pipelineId,\n      sessionId: this.sessionId,\n      audio: this.audio ? this.audio.subarray(0) : new Uint8Array(),\n      endOfStream: this.endOfStream,\n      initialIntentDisplayName: this.initialIntentDisplayName\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  ): S2sStreamRequest.AsProtobufJSON {\n    return {\n      pipelineId: this.pipelineId,\n      sessionId: this.sessionId,\n      audio: this.audio ? uint8ArrayToBase64(this.audio) : '',\n      endOfStream: this.endOfStream,\n      initialIntentDisplayName: this.initialIntentDisplayName\n    };\n  }\n}\nexport module S2sStreamRequest {\n  /**\n   * Standard JavaScript object representation for S2sStreamRequest\n   */\n  export interface AsObject {\n    pipelineId?: string;\n    sessionId?: string;\n    audio?: Uint8Array;\n    endOfStream?: boolean;\n    initialIntentDisplayName?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for S2sStreamRequest\n   */\n  export interface AsProtobufJSON {\n    pipelineId?: string;\n    sessionId?: string;\n    audio?: string;\n    endOfStream?: boolean;\n    initialIntentDisplayName?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.S2sStreamResponse\n */\nexport class S2sStreamResponse implements GrpcMessage {\n  static id = 'ondewo.csi.S2sStreamResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new S2sStreamResponse();\n    S2sStreamResponse.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: S2sStreamResponse) {}\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: S2sStreamResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.detectIntentResponse = new ondewoNlu011.DetectIntentResponse();\n          _reader.readMessage(\n            _instance.detectIntentResponse,\n            ondewoNlu011.DetectIntentResponse.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.synthetizeResponse = new ondewoT2s012.SynthesizeResponse();\n          _reader.readMessage(\n            _instance.synthetizeResponse,\n            ondewoT2s012.SynthesizeResponse.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.sipTrigger = new SipTrigger();\n          _reader.readMessage(\n            _instance.sipTrigger,\n            SipTrigger.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    S2sStreamResponse.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: S2sStreamResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.detectIntentResponse) {\n      _writer.writeMessage(\n        1,\n        _instance.detectIntentResponse as any,\n        ondewoNlu011.DetectIntentResponse.serializeBinaryToWriter\n      );\n    }\n    if (_instance.synthetizeResponse) {\n      _writer.writeMessage(\n        2,\n        _instance.synthetizeResponse as any,\n        ondewoT2s012.SynthesizeResponse.serializeBinaryToWriter\n      );\n    }\n    if (_instance.sipTrigger) {\n      _writer.writeMessage(\n        3,\n        _instance.sipTrigger as any,\n        SipTrigger.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _detectIntentResponse?: ondewoNlu011.DetectIntentResponse;\n  private _synthetizeResponse?: ondewoT2s012.SynthesizeResponse;\n  private _sipTrigger?: SipTrigger;\n\n  private _response: S2sStreamResponse.ResponseCase =\n    S2sStreamResponse.ResponseCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of S2sStreamResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<S2sStreamResponse.AsObject>) {\n    _value = _value || {};\n    this.detectIntentResponse = _value.detectIntentResponse\n      ? new ondewoNlu011.DetectIntentResponse(_value.detectIntentResponse)\n      : undefined;\n    this.synthetizeResponse = _value.synthetizeResponse\n      ? new ondewoT2s012.SynthesizeResponse(_value.synthetizeResponse)\n      : undefined;\n    this.sipTrigger = _value.sipTrigger\n      ? new SipTrigger(_value.sipTrigger)\n      : undefined;\n    S2sStreamResponse.refineValues(this);\n  }\n  get detectIntentResponse(): ondewoNlu011.DetectIntentResponse | undefined {\n    return this._detectIntentResponse;\n  }\n  set detectIntentResponse(\n    value: ondewoNlu011.DetectIntentResponse | undefined\n  ) {\n    if (value !== undefined && value !== null) {\n      this._synthetizeResponse = this._sipTrigger = undefined;\n      this._response = S2sStreamResponse.ResponseCase.detectIntentResponse;\n    }\n    this._detectIntentResponse = value;\n  }\n  get synthetizeResponse(): ondewoT2s012.SynthesizeResponse | undefined {\n    return this._synthetizeResponse;\n  }\n  set synthetizeResponse(value: ondewoT2s012.SynthesizeResponse | undefined) {\n    if (value !== undefined && value !== null) {\n      this._detectIntentResponse = this._sipTrigger = undefined;\n      this._response = S2sStreamResponse.ResponseCase.synthetizeResponse;\n    }\n    this._synthetizeResponse = value;\n  }\n  get sipTrigger(): SipTrigger | undefined {\n    return this._sipTrigger;\n  }\n  set sipTrigger(value: SipTrigger | undefined) {\n    if (value !== undefined && value !== null) {\n      this._detectIntentResponse = this._synthetizeResponse = undefined;\n      this._response = S2sStreamResponse.ResponseCase.sipTrigger;\n    }\n    this._sipTrigger = value;\n  }\n  get response() {\n    return this._response;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    S2sStreamResponse.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(): S2sStreamResponse.AsObject {\n    return {\n      detectIntentResponse: this.detectIntentResponse\n        ? this.detectIntentResponse.toObject()\n        : undefined,\n      synthetizeResponse: this.synthetizeResponse\n        ? this.synthetizeResponse.toObject()\n        : undefined,\n      sipTrigger: this.sipTrigger ? this.sipTrigger.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  ): S2sStreamResponse.AsProtobufJSON {\n    return {\n      detectIntentResponse: this.detectIntentResponse\n        ? this.detectIntentResponse.toProtobufJSON(options)\n        : null,\n      synthetizeResponse: this.synthetizeResponse\n        ? this.synthetizeResponse.toProtobufJSON(options)\n        : null,\n      sipTrigger: this.sipTrigger\n        ? this.sipTrigger.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module S2sStreamResponse {\n  /**\n   * Standard JavaScript object representation for S2sStreamResponse\n   */\n  export interface AsObject {\n    detectIntentResponse?: ondewoNlu011.DetectIntentResponse.AsObject;\n    synthetizeResponse?: ondewoT2s012.SynthesizeResponse.AsObject;\n    sipTrigger?: SipTrigger.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for S2sStreamResponse\n   */\n  export interface AsProtobufJSON {\n    detectIntentResponse?: ondewoNlu011.DetectIntentResponse.AsProtobufJSON | null;\n    synthetizeResponse?: ondewoT2s012.SynthesizeResponse.AsProtobufJSON | null;\n    sipTrigger?: SipTrigger.AsProtobufJSON | null;\n  }\n  export enum ResponseCase {\n    none = 0,\n    detectIntentResponse = 1,\n    synthetizeResponse = 2,\n    sipTrigger = 3\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.SipTrigger\n */\nexport class SipTrigger implements GrpcMessage {\n  static id = 'ondewo.csi.SipTrigger';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipTrigger();\n    SipTrigger.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: SipTrigger) {\n    _instance.type = _instance.type || 0;\n    _instance.content = _instance.content || 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: SipTrigger,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.type = _reader.readEnum();\n          break;\n        case 2:\n          _instance.content = new googleProtobuf003.Struct();\n          _reader.readMessage(\n            _instance.content,\n            googleProtobuf003.Struct.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipTrigger.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(_instance: SipTrigger, _writer: BinaryWriter) {\n    if (_instance.type) {\n      _writer.writeEnum(1, _instance.type);\n    }\n    if (_instance.content) {\n      _writer.writeMessage(\n        2,\n        _instance.content as any,\n        googleProtobuf003.Struct.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _type?: SipTrigger.SipTriggerType;\n  private _content?: googleProtobuf003.Struct;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SipTrigger to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipTrigger.AsObject>) {\n    _value = _value || {};\n    this.type = _value.type;\n    this.content = _value.content\n      ? new googleProtobuf003.Struct(_value.content)\n      : undefined;\n    SipTrigger.refineValues(this);\n  }\n  get type(): SipTrigger.SipTriggerType | undefined {\n    return this._type;\n  }\n  set type(value: SipTrigger.SipTriggerType | undefined) {\n    this._type = value;\n  }\n  get content(): googleProtobuf003.Struct | undefined {\n    return this._content;\n  }\n  set content(value: googleProtobuf003.Struct | undefined) {\n    this._content = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipTrigger.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(): SipTrigger.AsObject {\n    return {\n      type: this.type,\n      content: this.content ? this.content.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  ): SipTrigger.AsProtobufJSON {\n    return {\n      type:\n        SipTrigger.SipTriggerType[\n          this.type === null || this.type === undefined ? 0 : this.type\n        ],\n      content: this.content ? this.content.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module SipTrigger {\n  /**\n   * Standard JavaScript object representation for SipTrigger\n   */\n  export interface AsObject {\n    type?: SipTrigger.SipTriggerType;\n    content?: googleProtobuf003.Struct.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for SipTrigger\n   */\n  export interface AsProtobufJSON {\n    type?: string;\n    content?: googleProtobuf003.Struct.AsProtobufJSON | null;\n  }\n  export enum SipTriggerType {\n    UNSPECIFIED = 0,\n    HANGUP = 1,\n    HUMAN_HANDOVER = 2,\n    SEND_NOW = 3,\n    PAUSE = 4\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.CheckUpstreamHealthResponse\n */\nexport class CheckUpstreamHealthResponse implements GrpcMessage {\n  static id = 'ondewo.csi.CheckUpstreamHealthResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CheckUpstreamHealthResponse();\n    CheckUpstreamHealthResponse.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: CheckUpstreamHealthResponse) {\n    _instance.s2tStatus = _instance.s2tStatus || undefined;\n    _instance.nluStatus = _instance.nluStatus || undefined;\n    _instance.t2sStatus = _instance.t2sStatus || 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: CheckUpstreamHealthResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.s2tStatus = new googleRpc004.Status();\n          _reader.readMessage(\n            _instance.s2tStatus,\n            googleRpc004.Status.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.nluStatus = new googleRpc004.Status();\n          _reader.readMessage(\n            _instance.nluStatus,\n            googleRpc004.Status.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.t2sStatus = new googleRpc004.Status();\n          _reader.readMessage(\n            _instance.t2sStatus,\n            googleRpc004.Status.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CheckUpstreamHealthResponse.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: CheckUpstreamHealthResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.s2tStatus) {\n      _writer.writeMessage(\n        1,\n        _instance.s2tStatus as any,\n        googleRpc004.Status.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nluStatus) {\n      _writer.writeMessage(\n        2,\n        _instance.nluStatus as any,\n        googleRpc004.Status.serializeBinaryToWriter\n      );\n    }\n    if (_instance.t2sStatus) {\n      _writer.writeMessage(\n        3,\n        _instance.t2sStatus as any,\n        googleRpc004.Status.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _s2tStatus?: googleRpc004.Status;\n  private _nluStatus?: googleRpc004.Status;\n  private _t2sStatus?: googleRpc004.Status;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CheckUpstreamHealthResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CheckUpstreamHealthResponse.AsObject>) {\n    _value = _value || {};\n    this.s2tStatus = _value.s2tStatus\n      ? new googleRpc004.Status(_value.s2tStatus)\n      : undefined;\n    this.nluStatus = _value.nluStatus\n      ? new googleRpc004.Status(_value.nluStatus)\n      : undefined;\n    this.t2sStatus = _value.t2sStatus\n      ? new googleRpc004.Status(_value.t2sStatus)\n      : undefined;\n    CheckUpstreamHealthResponse.refineValues(this);\n  }\n  get s2tStatus(): googleRpc004.Status | undefined {\n    return this._s2tStatus;\n  }\n  set s2tStatus(value: googleRpc004.Status | undefined) {\n    this._s2tStatus = value;\n  }\n  get nluStatus(): googleRpc004.Status | undefined {\n    return this._nluStatus;\n  }\n  set nluStatus(value: googleRpc004.Status | undefined) {\n    this._nluStatus = value;\n  }\n  get t2sStatus(): googleRpc004.Status | undefined {\n    return this._t2sStatus;\n  }\n  set t2sStatus(value: googleRpc004.Status | undefined) {\n    this._t2sStatus = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CheckUpstreamHealthResponse.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(): CheckUpstreamHealthResponse.AsObject {\n    return {\n      s2tStatus: this.s2tStatus ? this.s2tStatus.toObject() : undefined,\n      nluStatus: this.nluStatus ? this.nluStatus.toObject() : undefined,\n      t2sStatus: this.t2sStatus ? this.t2sStatus.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  ): CheckUpstreamHealthResponse.AsProtobufJSON {\n    return {\n      s2tStatus: this.s2tStatus ? this.s2tStatus.toProtobufJSON(options) : null,\n      nluStatus: this.nluStatus ? this.nluStatus.toProtobufJSON(options) : null,\n      t2sStatus: this.t2sStatus ? this.t2sStatus.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module CheckUpstreamHealthResponse {\n  /**\n   * Standard JavaScript object representation for CheckUpstreamHealthResponse\n   */\n  export interface AsObject {\n    s2tStatus?: googleRpc004.Status.AsObject;\n    nluStatus?: googleRpc004.Status.AsObject;\n    t2sStatus?: googleRpc004.Status.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for CheckUpstreamHealthResponse\n   */\n  export interface AsProtobufJSON {\n    s2tStatus?: googleRpc004.Status.AsProtobufJSON | null;\n    nluStatus?: googleRpc004.Status.AsProtobufJSON | null;\n    t2sStatus?: googleRpc004.Status.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.ControlStreamRequest\n */\nexport class ControlStreamRequest implements GrpcMessage {\n  static id = 'ondewo.csi.ControlStreamRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ControlStreamRequest();\n    ControlStreamRequest.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: ControlStreamRequest) {}\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: ControlStreamRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ControlStreamRequest.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: ControlStreamRequest,\n    _writer: BinaryWriter\n  ) {}\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ControlStreamRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ControlStreamRequest.AsObject>) {\n    _value = _value || {};\n    ControlStreamRequest.refineValues(this);\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ControlStreamRequest.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(): ControlStreamRequest.AsObject {\n    return {};\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  ): ControlStreamRequest.AsProtobufJSON {\n    return {};\n  }\n}\nexport module ControlStreamRequest {\n  /**\n   * Standard JavaScript object representation for ControlStreamRequest\n   */\n  export interface AsObject {}\n\n  /**\n   * Protobuf JSON representation for ControlStreamRequest\n   */\n  export interface AsProtobufJSON {}\n}\n\n/**\n * Message implementation for ondewo.csi.ControlStreamResponse\n */\nexport class ControlStreamResponse implements GrpcMessage {\n  static id = 'ondewo.csi.ControlStreamResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ControlStreamResponse();\n    ControlStreamResponse.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: ControlStreamResponse) {\n    _instance.controlStatus = _instance.controlStatus || 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: ControlStreamResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.controlStatus = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ControlStreamResponse.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: ControlStreamResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.controlStatus) {\n      _writer.writeEnum(1, _instance.controlStatus);\n    }\n  }\n\n  private _controlStatus?: ControlStatus;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ControlStreamResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ControlStreamResponse.AsObject>) {\n    _value = _value || {};\n    this.controlStatus = _value.controlStatus;\n    ControlStreamResponse.refineValues(this);\n  }\n  get controlStatus(): ControlStatus | undefined {\n    return this._controlStatus;\n  }\n  set controlStatus(value: ControlStatus | undefined) {\n    this._controlStatus = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ControlStreamResponse.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(): ControlStreamResponse.AsObject {\n    return {\n      controlStatus: this.controlStatus\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  ): ControlStreamResponse.AsProtobufJSON {\n    return {\n      controlStatus:\n        ControlStatus[\n          this.controlStatus === null || this.controlStatus === undefined\n            ? 0\n            : this.controlStatus\n        ]\n    };\n  }\n}\nexport module ControlStreamResponse {\n  /**\n   * Standard JavaScript object representation for ControlStreamResponse\n   */\n  export interface AsObject {\n    controlStatus?: ControlStatus;\n  }\n\n  /**\n   * Protobuf JSON representation for ControlStreamResponse\n   */\n  export interface AsProtobufJSON {\n    controlStatus?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.SetControlStatusRequest\n */\nexport class SetControlStatusRequest implements GrpcMessage {\n  static id = 'ondewo.csi.SetControlStatusRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SetControlStatusRequest();\n    SetControlStatusRequest.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: SetControlStatusRequest) {\n    _instance.controlStatus = _instance.controlStatus || 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: SetControlStatusRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.controlStatus = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SetControlStatusRequest.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: SetControlStatusRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.controlStatus) {\n      _writer.writeEnum(1, _instance.controlStatus);\n    }\n  }\n\n  private _controlStatus?: ControlStatus;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SetControlStatusRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SetControlStatusRequest.AsObject>) {\n    _value = _value || {};\n    this.controlStatus = _value.controlStatus;\n    SetControlStatusRequest.refineValues(this);\n  }\n  get controlStatus(): ControlStatus | undefined {\n    return this._controlStatus;\n  }\n  set controlStatus(value: ControlStatus | undefined) {\n    this._controlStatus = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SetControlStatusRequest.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(): SetControlStatusRequest.AsObject {\n    return {\n      controlStatus: this.controlStatus\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  ): SetControlStatusRequest.AsProtobufJSON {\n    return {\n      controlStatus:\n        ControlStatus[\n          this.controlStatus === null || this.controlStatus === undefined\n            ? 0\n            : this.controlStatus\n        ]\n    };\n  }\n}\nexport module SetControlStatusRequest {\n  /**\n   * Standard JavaScript object representation for SetControlStatusRequest\n   */\n  export interface AsObject {\n    controlStatus?: ControlStatus;\n  }\n\n  /**\n   * Protobuf JSON representation for SetControlStatusRequest\n   */\n  export interface AsProtobufJSON {\n    controlStatus?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.SetControlStatusResponse\n */\nexport class SetControlStatusResponse implements GrpcMessage {\n  static id = 'ondewo.csi.SetControlStatusResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SetControlStatusResponse();\n    SetControlStatusResponse.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: SetControlStatusResponse) {\n    _instance.oldControlStatus = _instance.oldControlStatus || 0;\n    _instance.newControlStatus = _instance.newControlStatus || 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: SetControlStatusResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.oldControlStatus = _reader.readEnum();\n          break;\n        case 2:\n          _instance.newControlStatus = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SetControlStatusResponse.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: SetControlStatusResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.oldControlStatus) {\n      _writer.writeEnum(1, _instance.oldControlStatus);\n    }\n    if (_instance.newControlStatus) {\n      _writer.writeEnum(2, _instance.newControlStatus);\n    }\n  }\n\n  private _oldControlStatus?: ControlStatus;\n  private _newControlStatus?: ControlStatus;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SetControlStatusResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SetControlStatusResponse.AsObject>) {\n    _value = _value || {};\n    this.oldControlStatus = _value.oldControlStatus;\n    this.newControlStatus = _value.newControlStatus;\n    SetControlStatusResponse.refineValues(this);\n  }\n  get oldControlStatus(): ControlStatus | undefined {\n    return this._oldControlStatus;\n  }\n  set oldControlStatus(value: ControlStatus | undefined) {\n    this._oldControlStatus = value;\n  }\n  get newControlStatus(): ControlStatus | undefined {\n    return this._newControlStatus;\n  }\n  set newControlStatus(value: ControlStatus | undefined) {\n    this._newControlStatus = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SetControlStatusResponse.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(): SetControlStatusResponse.AsObject {\n    return {\n      oldControlStatus: this.oldControlStatus,\n      newControlStatus: this.newControlStatus\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  ): SetControlStatusResponse.AsProtobufJSON {\n    return {\n      oldControlStatus:\n        ControlStatus[\n          this.oldControlStatus === null || this.oldControlStatus === undefined\n            ? 0\n            : this.oldControlStatus\n        ],\n      newControlStatus:\n        ControlStatus[\n          this.newControlStatus === null || this.newControlStatus === undefined\n            ? 0\n            : this.newControlStatus\n        ]\n    };\n  }\n}\nexport module SetControlStatusResponse {\n  /**\n   * Standard JavaScript object representation for SetControlStatusResponse\n   */\n  export interface AsObject {\n    oldControlStatus?: ControlStatus;\n    newControlStatus?: ControlStatus;\n  }\n\n  /**\n   * Protobuf JSON representation for SetControlStatusResponse\n   */\n  export interface AsProtobufJSON {\n    oldControlStatus?: string;\n    newControlStatus?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.CondtionValueUnion\n */\nexport class CondtionValueUnion implements GrpcMessage {\n  static id = 'ondewo.csi.CondtionValueUnion';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CondtionValueUnion();\n    CondtionValueUnion.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: CondtionValueUnion) {}\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: CondtionValueUnion,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.intValue = _reader.readInt64String();\n          break;\n        case 2:\n          _instance.floatValue = _reader.readFloat();\n          break;\n        case 3:\n          _instance.datetimeValue = new googleProtobuf010.Timestamp();\n          _reader.readMessage(\n            _instance.datetimeValue,\n            googleProtobuf010.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CondtionValueUnion.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: CondtionValueUnion,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.intValue || _instance.intValue === '0') {\n      _writer.writeInt64String(1, _instance.intValue);\n    }\n    if (_instance.floatValue || _instance.floatValue === 0) {\n      _writer.writeFloat(2, _instance.floatValue);\n    }\n    if (_instance.datetimeValue) {\n      _writer.writeMessage(\n        3,\n        _instance.datetimeValue as any,\n        googleProtobuf010.Timestamp.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _intValue?: string;\n  private _floatValue?: number;\n  private _datetimeValue?: googleProtobuf010.Timestamp;\n\n  private _unionOneof: CondtionValueUnion.UnionOneofCase =\n    CondtionValueUnion.UnionOneofCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CondtionValueUnion to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CondtionValueUnion.AsObject>) {\n    _value = _value || {};\n    this.intValue = _value.intValue;\n    this.floatValue = _value.floatValue;\n    this.datetimeValue = _value.datetimeValue\n      ? new googleProtobuf010.Timestamp(_value.datetimeValue)\n      : undefined;\n    CondtionValueUnion.refineValues(this);\n  }\n  get intValue(): string | undefined {\n    return this._intValue;\n  }\n  set intValue(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._floatValue = this._datetimeValue = undefined;\n      this._unionOneof = CondtionValueUnion.UnionOneofCase.intValue;\n    }\n    this._intValue = value;\n  }\n  get floatValue(): number | undefined {\n    return this._floatValue;\n  }\n  set floatValue(value: number | undefined) {\n    if (value !== undefined && value !== null) {\n      this._intValue = this._datetimeValue = undefined;\n      this._unionOneof = CondtionValueUnion.UnionOneofCase.floatValue;\n    }\n    this._floatValue = value;\n  }\n  get datetimeValue(): googleProtobuf010.Timestamp | undefined {\n    return this._datetimeValue;\n  }\n  set datetimeValue(value: googleProtobuf010.Timestamp | undefined) {\n    if (value !== undefined && value !== null) {\n      this._intValue = this._floatValue = undefined;\n      this._unionOneof = CondtionValueUnion.UnionOneofCase.datetimeValue;\n    }\n    this._datetimeValue = value;\n  }\n  get unionOneof() {\n    return this._unionOneof;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CondtionValueUnion.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(): CondtionValueUnion.AsObject {\n    return {\n      intValue: this.intValue,\n      floatValue: this.floatValue,\n      datetimeValue: this.datetimeValue\n        ? this.datetimeValue.toObject()\n        : 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  ): CondtionValueUnion.AsProtobufJSON {\n    return {\n      intValue:\n        this.intValue === null || this.intValue === undefined\n          ? null\n          : this.intValue,\n      floatValue:\n        this.floatValue === null || this.floatValue === undefined\n          ? null\n          : this.floatValue,\n      datetimeValue: this.datetimeValue\n        ? this.datetimeValue.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module CondtionValueUnion {\n  /**\n   * Standard JavaScript object representation for CondtionValueUnion\n   */\n  export interface AsObject {\n    intValue?: string;\n    floatValue?: number;\n    datetimeValue?: googleProtobuf010.Timestamp.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for CondtionValueUnion\n   */\n  export interface AsProtobufJSON {\n    intValue?: string | null;\n    floatValue?: number | null;\n    datetimeValue?: googleProtobuf010.Timestamp.AsProtobufJSON | null;\n  }\n  export enum UnionOneofCase {\n    none = 0,\n    intValue = 1,\n    floatValue = 2,\n    datetimeValue = 3\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.Condition\n */\nexport class Condition implements GrpcMessage {\n  static id = 'ondewo.csi.Condition';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Condition();\n    Condition.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: Condition) {\n    _instance.type = _instance.type || 0;\n    _instance.value = _instance.value || '';\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: Condition,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.type = _reader.readEnum();\n          break;\n        case 2:\n          _instance.value = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Condition.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(_instance: Condition, _writer: BinaryWriter) {\n    if (_instance.type) {\n      _writer.writeEnum(1, _instance.type);\n    }\n    if (_instance.value) {\n      _writer.writeString(2, _instance.value);\n    }\n  }\n\n  private _type?: ConditionType;\n  private _value?: 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 Condition to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Condition.AsObject>) {\n    _value = _value || {};\n    this.type = _value.type;\n    this.value = _value.value;\n    Condition.refineValues(this);\n  }\n  get type(): ConditionType | undefined {\n    return this._type;\n  }\n  set type(value: ConditionType | undefined) {\n    this._type = value;\n  }\n  get value(): string | undefined {\n    return this._value;\n  }\n  set value(value: string | 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    Condition.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(): Condition.AsObject {\n    return {\n      type: this.type,\n      value: this.value\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): Condition.AsProtobufJSON {\n    return {\n      type:\n        ConditionType[\n          this.type === null || this.type === undefined ? 0 : this.type\n        ],\n      value: this.value\n    };\n  }\n}\nexport module Condition {\n  /**\n   * Standard JavaScript object representation for Condition\n   */\n  export interface AsObject {\n    type?: ConditionType;\n    value?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for Condition\n   */\n  export interface AsProtobufJSON {\n    type?: string;\n    value?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.ControlMessageServiceParameters\n */\nexport class ControlMessageServiceParameters implements GrpcMessage {\n  static id = 'ondewo.csi.ControlMessageServiceParameters';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ControlMessageServiceParameters();\n    ControlMessageServiceParameters.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: ControlMessageServiceParameters) {\n    _instance.transferId = _instance.transferId || '';\n    _instance.wavFiles = _instance.wavFiles || [];\n    _instance.text = _instance.text || '';\n    _instance.context = _instance.context || undefined;\n    _instance.sessionId = _instance.sessionId || '';\n    _instance.contextName = _instance.contextName || '';\n    _instance.conditionStart = _instance.conditionStart || undefined;\n    _instance.conditionEnd = _instance.conditionEnd || 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: ControlMessageServiceParameters,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.t2sConfig = new ondewoT2s012.RequestConfig();\n          _reader.readMessage(\n            _instance.t2sConfig,\n            ondewoT2s012.RequestConfig.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.s2tConfig = new ondewoS2t013.TranscribeRequestConfig();\n          _reader.readMessage(\n            _instance.s2tConfig,\n            ondewoS2t013.TranscribeRequestConfig.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.transferId = _reader.readString();\n          break;\n        case 4:\n          (_instance.wavFiles = _instance.wavFiles || []).push(\n            _reader.readBytes()\n          );\n          break;\n        case 5:\n          _instance.text = _reader.readString();\n          break;\n        case 6:\n          _instance.context = new ondewoNlu006.Context();\n          _reader.readMessage(\n            _instance.context,\n            ondewoNlu006.Context.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.sessionId = _reader.readString();\n          break;\n        case 8:\n          _instance.contextName = _reader.readString();\n          break;\n        case 9:\n          _instance.conditionStart = new Condition();\n          _reader.readMessage(\n            _instance.conditionStart,\n            Condition.deserializeBinaryFromReader\n          );\n          break;\n        case 10:\n          _instance.conditionEnd = new Condition();\n          _reader.readMessage(\n            _instance.conditionEnd,\n            Condition.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ControlMessageServiceParameters.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: ControlMessageServiceParameters,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.t2sConfig) {\n      _writer.writeMessage(\n        1,\n        _instance.t2sConfig as any,\n        ondewoT2s012.RequestConfig.serializeBinaryToWriter\n      );\n    }\n    if (_instance.s2tConfig) {\n      _writer.writeMessage(\n        2,\n        _instance.s2tConfig as any,\n        ondewoS2t013.TranscribeRequestConfig.serializeBinaryToWriter\n      );\n    }\n    if (_instance.transferId) {\n      _writer.writeString(3, _instance.transferId);\n    }\n    if (_instance.wavFiles && _instance.wavFiles.length) {\n      _writer.writeRepeatedBytes(4, _instance.wavFiles);\n    }\n    if (_instance.text) {\n      _writer.writeString(5, _instance.text);\n    }\n    if (_instance.context) {\n      _writer.writeMessage(\n        6,\n        _instance.context as any,\n        ondewoNlu006.Context.serializeBinaryToWriter\n      );\n    }\n    if (_instance.sessionId) {\n      _writer.writeString(7, _instance.sessionId);\n    }\n    if (_instance.contextName) {\n      _writer.writeString(8, _instance.contextName);\n    }\n    if (_instance.conditionStart) {\n      _writer.writeMessage(\n        9,\n        _instance.conditionStart as any,\n        Condition.serializeBinaryToWriter\n      );\n    }\n    if (_instance.conditionEnd) {\n      _writer.writeMessage(\n        10,\n        _instance.conditionEnd as any,\n        Condition.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _t2sConfig?: ondewoT2s012.RequestConfig;\n  private _s2tConfig?: ondewoS2t013.TranscribeRequestConfig;\n  private _transferId?: string;\n  private _wavFiles?: Uint8Array[];\n  private _text?: string;\n  private _context?: ondewoNlu006.Context;\n  private _sessionId?: string;\n  private _contextName?: string;\n  private _conditionStart?: Condition;\n  private _conditionEnd?: Condition;\n\n  private _config: ControlMessageServiceParameters.ConfigCase =\n    ControlMessageServiceParameters.ConfigCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ControlMessageServiceParameters to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<ControlMessageServiceParameters.AsObject>\n  ) {\n    _value = _value || {};\n    this.t2sConfig = _value.t2sConfig\n      ? new ondewoT2s012.RequestConfig(_value.t2sConfig)\n      : undefined;\n    this.s2tConfig = _value.s2tConfig\n      ? new ondewoS2t013.TranscribeRequestConfig(_value.s2tConfig)\n      : undefined;\n    this.transferId = _value.transferId;\n    this.wavFiles = (_value.wavFiles || []).map(b =>\n      b ? b.subarray(0) : new Uint8Array()\n    );\n    this.text = _value.text;\n    this.context = _value.context\n      ? new ondewoNlu006.Context(_value.context)\n      : undefined;\n    this.sessionId = _value.sessionId;\n    this.contextName = _value.contextName;\n    this.conditionStart = _value.conditionStart\n      ? new Condition(_value.conditionStart)\n      : undefined;\n    this.conditionEnd = _value.conditionEnd\n      ? new Condition(_value.conditionEnd)\n      : undefined;\n    ControlMessageServiceParameters.refineValues(this);\n  }\n  get t2sConfig(): ondewoT2s012.RequestConfig | undefined {\n    return this._t2sConfig;\n  }\n  set t2sConfig(value: ondewoT2s012.RequestConfig | undefined) {\n    if (value !== undefined && value !== null) {\n      this._s2tConfig = undefined;\n      this._config = ControlMessageServiceParameters.ConfigCase.t2sConfig;\n    }\n    this._t2sConfig = value;\n  }\n  get s2tConfig(): ondewoS2t013.TranscribeRequestConfig | undefined {\n    return this._s2tConfig;\n  }\n  set s2tConfig(value: ondewoS2t013.TranscribeRequestConfig | undefined) {\n    if (value !== undefined && value !== null) {\n      this._t2sConfig = undefined;\n      this._config = ControlMessageServiceParameters.ConfigCase.s2tConfig;\n    }\n    this._s2tConfig = value;\n  }\n  get transferId(): string | undefined {\n    return this._transferId;\n  }\n  set transferId(value: string | undefined) {\n    this._transferId = value;\n  }\n  get wavFiles(): Uint8Array[] | undefined {\n    return this._wavFiles;\n  }\n  set wavFiles(value: Uint8Array[] | undefined) {\n    this._wavFiles = value;\n  }\n  get text(): string | undefined {\n    return this._text;\n  }\n  set text(value: string | undefined) {\n    this._text = value;\n  }\n  get context(): ondewoNlu006.Context | undefined {\n    return this._context;\n  }\n  set context(value: ondewoNlu006.Context | undefined) {\n    this._context = value;\n  }\n  get sessionId(): string | undefined {\n    return this._sessionId;\n  }\n  set sessionId(value: string | undefined) {\n    this._sessionId = value;\n  }\n  get contextName(): string | undefined {\n    return this._contextName;\n  }\n  set contextName(value: string | undefined) {\n    this._contextName = value;\n  }\n  get conditionStart(): Condition | undefined {\n    return this._conditionStart;\n  }\n  set conditionStart(value: Condition | undefined) {\n    this._conditionStart = value;\n  }\n  get conditionEnd(): Condition | undefined {\n    return this._conditionEnd;\n  }\n  set conditionEnd(value: Condition | undefined) {\n    this._conditionEnd = value;\n  }\n  get config() {\n    return this._config;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ControlMessageServiceParameters.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(): ControlMessageServiceParameters.AsObject {\n    return {\n      t2sConfig: this.t2sConfig ? this.t2sConfig.toObject() : undefined,\n      s2tConfig: this.s2tConfig ? this.s2tConfig.toObject() : undefined,\n      transferId: this.transferId,\n      wavFiles: (this.wavFiles || []).map(b =>\n        b ? b.subarray(0) : new Uint8Array()\n      ),\n      text: this.text,\n      context: this.context ? this.context.toObject() : undefined,\n      sessionId: this.sessionId,\n      contextName: this.contextName,\n      conditionStart: this.conditionStart\n        ? this.conditionStart.toObject()\n        : undefined,\n      conditionEnd: this.conditionEnd ? this.conditionEnd.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  ): ControlMessageServiceParameters.AsProtobufJSON {\n    return {\n      t2sConfig: this.t2sConfig ? this.t2sConfig.toProtobufJSON(options) : null,\n      s2tConfig: this.s2tConfig ? this.s2tConfig.toProtobufJSON(options) : null,\n      transferId: this.transferId,\n      wavFiles: (this.wavFiles || []).map(b =>\n        b ? uint8ArrayToBase64(b) : ''\n      ),\n      text: this.text,\n      context: this.context ? this.context.toProtobufJSON(options) : null,\n      sessionId: this.sessionId,\n      contextName: this.contextName,\n      conditionStart: this.conditionStart\n        ? this.conditionStart.toProtobufJSON(options)\n        : null,\n      conditionEnd: this.conditionEnd\n        ? this.conditionEnd.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module ControlMessageServiceParameters {\n  /**\n   * Standard JavaScript object representation for ControlMessageServiceParameters\n   */\n  export interface AsObject {\n    t2sConfig?: ondewoT2s012.RequestConfig.AsObject;\n    s2tConfig?: ondewoS2t013.TranscribeRequestConfig.AsObject;\n    transferId?: string;\n    wavFiles?: Uint8Array[];\n    text?: string;\n    context?: ondewoNlu006.Context.AsObject;\n    sessionId?: string;\n    contextName?: string;\n    conditionStart?: Condition.AsObject;\n    conditionEnd?: Condition.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ControlMessageServiceParameters\n   */\n  export interface AsProtobufJSON {\n    t2sConfig?: ondewoT2s012.RequestConfig.AsProtobufJSON | null;\n    s2tConfig?: ondewoS2t013.TranscribeRequestConfig.AsProtobufJSON | null;\n    transferId?: string;\n    wavFiles?: string[];\n    text?: string;\n    context?: ondewoNlu006.Context.AsProtobufJSON | null;\n    sessionId?: string;\n    contextName?: string;\n    conditionStart?: Condition.AsProtobufJSON | null;\n    conditionEnd?: Condition.AsProtobufJSON | null;\n  }\n  export enum ConfigCase {\n    none = 0,\n    t2sConfig = 1,\n    s2tConfig = 2\n  }\n}\n\n/**\n * Message implementation for ondewo.csi.ControlMessage\n */\nexport class ControlMessage implements GrpcMessage {\n  static id = 'ondewo.csi.ControlMessage';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ControlMessage();\n    ControlMessage.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: ControlMessage) {\n    _instance.service = _instance.service || 0;\n    _instance.method = _instance.method || 0;\n    _instance.parameters = _instance.parameters || 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: ControlMessage,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.service = _reader.readEnum();\n          break;\n        case 2:\n          _instance.method = _reader.readEnum();\n          break;\n        case 3:\n          _instance.parameters = new ControlMessageServiceParameters();\n          _reader.readMessage(\n            _instance.parameters,\n            ControlMessageServiceParameters.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ControlMessage.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: ControlMessage,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.service) {\n      _writer.writeEnum(1, _instance.service);\n    }\n    if (_instance.method) {\n      _writer.writeEnum(2, _instance.method);\n    }\n    if (_instance.parameters) {\n      _writer.writeMessage(\n        3,\n        _instance.parameters as any,\n        ControlMessageServiceParameters.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _service?: ControlMessageServiceName;\n  private _method?: ControlMessageServiceMethod;\n  private _parameters?: ControlMessageServiceParameters;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ControlMessage to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ControlMessage.AsObject>) {\n    _value = _value || {};\n    this.service = _value.service;\n    this.method = _value.method;\n    this.parameters = _value.parameters\n      ? new ControlMessageServiceParameters(_value.parameters)\n      : undefined;\n    ControlMessage.refineValues(this);\n  }\n  get service(): ControlMessageServiceName | undefined {\n    return this._service;\n  }\n  set service(value: ControlMessageServiceName | undefined) {\n    this._service = value;\n  }\n  get method(): ControlMessageServiceMethod | undefined {\n    return this._method;\n  }\n  set method(value: ControlMessageServiceMethod | undefined) {\n    this._method = value;\n  }\n  get parameters(): ControlMessageServiceParameters | undefined {\n    return this._parameters;\n  }\n  set parameters(value: ControlMessageServiceParameters | undefined) {\n    this._parameters = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ControlMessage.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(): ControlMessage.AsObject {\n    return {\n      service: this.service,\n      method: this.method,\n      parameters: this.parameters ? this.parameters.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  ): ControlMessage.AsProtobufJSON {\n    return {\n      service:\n        ControlMessageServiceName[\n          this.service === null || this.service === undefined ? 0 : this.service\n        ],\n      method:\n        ControlMessageServiceMethod[\n          this.method === null || this.method === undefined ? 0 : this.method\n        ],\n      parameters: this.parameters\n        ? this.parameters.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module ControlMessage {\n  /**\n   * Standard JavaScript object representation for ControlMessage\n   */\n  export interface AsObject {\n    service?: ControlMessageServiceName;\n    method?: ControlMessageServiceMethod;\n    parameters?: ControlMessageServiceParameters.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ControlMessage\n   */\n  export interface AsProtobufJSON {\n    service?: string;\n    method?: string;\n    parameters?: ControlMessageServiceParameters.AsProtobufJSON | null;\n  }\n}\n"]}