@ondewo/sip-client-angular 4.0.0 → 5.2.0

package/esm2022/api/ondewo/sip/sip.pb.mjs

@@ -0,0 +1,1495 @@
+/* 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 googleProtobuf001 from '@ngx-grpc/well-known-types';
+/**
+ * Message implementation for ondewo.sip.SipEndCallRequest
+ */
+export class SipEndCallRequest {
+    static { this.id = 'ondewo.sip.SipEndCallRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipEndCallRequest();
+        SipEndCallRequest.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.hardHangup = _instance.hardHangup || false;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.hardHangup = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipEndCallRequest.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.hardHangup) {
+            _writer.writeBool(1, _instance.hardHangup);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipEndCallRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.hardHangup = _value.hardHangup;
+        SipEndCallRequest.refineValues(this);
+    }
+    get hardHangup() {
+        return this._hardHangup;
+    }
+    set hardHangup(value) {
+        this._hardHangup = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipEndCallRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            hardHangup: this.hardHangup
+        };
+    }
+    /**
+     * 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 {
+            hardHangup: this.hardHangup
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.sip.SipStartCallRequest
+ */
+export class SipStartCallRequest {
+    static { this.id = 'ondewo.sip.SipStartCallRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipStartCallRequest();
+        SipStartCallRequest.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.calleeId = _instance.calleeId || '';
+        _instance.headers = _instance.headers || {};
+    }
+    /**
+     * 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.calleeId = _reader.readString();
+                    break;
+                case 2:
+                    const msg_2 = {};
+                    _reader.readMessage(msg_2, SipStartCallRequest.HeadersEntry.deserializeBinaryFromReader);
+                    _instance.headers = _instance.headers || {};
+                    _instance.headers[msg_2.key] = msg_2.value;
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipStartCallRequest.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.calleeId) {
+            _writer.writeString(1, _instance.calleeId);
+        }
+        if (!!_instance.headers) {
+            const keys_2 = Object.keys(_instance.headers);
+            if (keys_2.length) {
+                const repeated_2 = keys_2
+                    .map(key => ({ key: key, value: _instance.headers[key] }))
+                    .reduce((r, v) => [...r, v], []);
+                _writer.writeRepeatedMessage(2, repeated_2, SipStartCallRequest.HeadersEntry.serializeBinaryToWriter);
+            }
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipStartCallRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.calleeId = _value.calleeId;
+        (this.headers = _value.headers
+            ? Object.keys(_value.headers).reduce((r, k) => ({ ...r, [k]: _value.headers[k] }), {})
+            : {}),
+            SipStartCallRequest.refineValues(this);
+    }
+    get calleeId() {
+        return this._calleeId;
+    }
+    set calleeId(value) {
+        this._calleeId = value;
+    }
+    get headers() {
+        return this._headers;
+    }
+    set headers(value) {
+        this._headers = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipStartCallRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            calleeId: this.calleeId,
+            headers: this.headers
+                ? Object.keys(this.headers).reduce((r, k) => ({ ...r, [k]: this.headers[k] }), {})
+                : {}
+        };
+    }
+    /**
+     * 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 {
+            calleeId: this.calleeId,
+            headers: this.headers
+                ? Object.keys(this.headers).reduce((r, k) => ({ ...r, [k]: this.headers[k] }), {})
+                : {}
+        };
+    }
+}
+(function (SipStartCallRequest) {
+    /**
+     * Message implementation for ondewo.sip.SipStartCallRequest.HeadersEntry
+     */
+    class HeadersEntry {
+        static { this.id = 'ondewo.sip.SipStartCallRequest.HeadersEntry'; }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new HeadersEntry();
+            HeadersEntry.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.key = _instance.key || '';
+            _instance.value = _instance.value || '';
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.key = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.value = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            HeadersEntry.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.key) {
+                _writer.writeString(1, _instance.key);
+            }
+            if (_instance.value) {
+                _writer.writeString(2, _instance.value);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of HeadersEntry to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.key = _value.key;
+            this.value = _value.value;
+            HeadersEntry.refineValues(this);
+        }
+        get key() {
+            return this._key;
+        }
+        set key(value) {
+            this._key = value;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            HeadersEntry.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+    }
+    SipStartCallRequest.HeadersEntry = HeadersEntry;
+})(SipStartCallRequest || (SipStartCallRequest = {}));
+/**
+ * Message implementation for ondewo.sip.SipRegisterAccountRequest
+ */
+export class SipRegisterAccountRequest {
+    static { this.id = 'ondewo.sip.SipRegisterAccountRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipRegisterAccountRequest();
+        SipRegisterAccountRequest.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.accountName = _instance.accountName || '';
+        _instance.password = _instance.password || '';
+        _instance.authUsername = _instance.authUsername || '';
+        _instance.outboundProxy = _instance.outboundProxy || '';
+    }
+    /**
+     * 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.accountName = _reader.readString();
+                    break;
+                case 2:
+                    _instance.password = _reader.readString();
+                    break;
+                case 3:
+                    _instance.authUsername = _reader.readString();
+                    break;
+                case 4:
+                    _instance.outboundProxy = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipRegisterAccountRequest.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.accountName) {
+            _writer.writeString(1, _instance.accountName);
+        }
+        if (_instance.password) {
+            _writer.writeString(2, _instance.password);
+        }
+        if (_instance.authUsername) {
+            _writer.writeString(3, _instance.authUsername);
+        }
+        if (_instance.outboundProxy) {
+            _writer.writeString(4, _instance.outboundProxy);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipRegisterAccountRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.accountName = _value.accountName;
+        this.password = _value.password;
+        this.authUsername = _value.authUsername;
+        this.outboundProxy = _value.outboundProxy;
+        SipRegisterAccountRequest.refineValues(this);
+    }
+    get accountName() {
+        return this._accountName;
+    }
+    set accountName(value) {
+        this._accountName = value;
+    }
+    get password() {
+        return this._password;
+    }
+    set password(value) {
+        this._password = value;
+    }
+    get authUsername() {
+        return this._authUsername;
+    }
+    set authUsername(value) {
+        this._authUsername = value;
+    }
+    get outboundProxy() {
+        return this._outboundProxy;
+    }
+    set outboundProxy(value) {
+        this._outboundProxy = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipRegisterAccountRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            accountName: this.accountName,
+            password: this.password,
+            authUsername: this.authUsername,
+            outboundProxy: this.outboundProxy
+        };
+    }
+    /**
+     * 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 {
+            accountName: this.accountName,
+            password: this.password,
+            authUsername: this.authUsername,
+            outboundProxy: this.outboundProxy
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.sip.SipStartSessionRequest
+ */
+export class SipStartSessionRequest {
+    static { this.id = 'ondewo.sip.SipStartSessionRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipStartSessionRequest();
+        SipStartSessionRequest.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.accountName = _instance.accountName || '';
+        _instance.autoAnswerInterval = _instance.autoAnswerInterval || 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.accountName = _reader.readString();
+                    break;
+                case 2:
+                    _instance.autoAnswerInterval = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipStartSessionRequest.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.accountName) {
+            _writer.writeString(1, _instance.accountName);
+        }
+        if (_instance.autoAnswerInterval) {
+            _writer.writeInt32(2, _instance.autoAnswerInterval);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipStartSessionRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.accountName = _value.accountName;
+        this.autoAnswerInterval = _value.autoAnswerInterval;
+        SipStartSessionRequest.refineValues(this);
+    }
+    get accountName() {
+        return this._accountName;
+    }
+    set accountName(value) {
+        this._accountName = value;
+    }
+    get autoAnswerInterval() {
+        return this._autoAnswerInterval;
+    }
+    set autoAnswerInterval(value) {
+        this._autoAnswerInterval = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipStartSessionRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            accountName: this.accountName,
+            autoAnswerInterval: this.autoAnswerInterval
+        };
+    }
+    /**
+     * 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 {
+            accountName: this.accountName,
+            autoAnswerInterval: this.autoAnswerInterval
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.sip.SipTransferCallRequest
+ */
+export class SipTransferCallRequest {
+    static { this.id = 'ondewo.sip.SipTransferCallRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipTransferCallRequest();
+        SipTransferCallRequest.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.headers = _instance.headers || {};
+    }
+    /**
+     * 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.transferId = _reader.readString();
+                    break;
+                case 2:
+                    const msg_2 = {};
+                    _reader.readMessage(msg_2, SipTransferCallRequest.HeadersEntry.deserializeBinaryFromReader);
+                    _instance.headers = _instance.headers || {};
+                    _instance.headers[msg_2.key] = msg_2.value;
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipTransferCallRequest.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.transferId) {
+            _writer.writeString(1, _instance.transferId);
+        }
+        if (!!_instance.headers) {
+            const keys_2 = Object.keys(_instance.headers);
+            if (keys_2.length) {
+                const repeated_2 = keys_2
+                    .map(key => ({ key: key, value: _instance.headers[key] }))
+                    .reduce((r, v) => [...r, v], []);
+                _writer.writeRepeatedMessage(2, repeated_2, SipTransferCallRequest.HeadersEntry.serializeBinaryToWriter);
+            }
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipTransferCallRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.transferId = _value.transferId;
+        (this.headers = _value.headers
+            ? Object.keys(_value.headers).reduce((r, k) => ({ ...r, [k]: _value.headers[k] }), {})
+            : {}),
+            SipTransferCallRequest.refineValues(this);
+    }
+    get transferId() {
+        return this._transferId;
+    }
+    set transferId(value) {
+        this._transferId = value;
+    }
+    get headers() {
+        return this._headers;
+    }
+    set headers(value) {
+        this._headers = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipTransferCallRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            transferId: this.transferId,
+            headers: this.headers
+                ? Object.keys(this.headers).reduce((r, k) => ({ ...r, [k]: this.headers[k] }), {})
+                : {}
+        };
+    }
+    /**
+     * 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 {
+            transferId: this.transferId,
+            headers: this.headers
+                ? Object.keys(this.headers).reduce((r, k) => ({ ...r, [k]: this.headers[k] }), {})
+                : {}
+        };
+    }
+}
+(function (SipTransferCallRequest) {
+    /**
+     * Message implementation for ondewo.sip.SipTransferCallRequest.HeadersEntry
+     */
+    class HeadersEntry {
+        static { this.id = 'ondewo.sip.SipTransferCallRequest.HeadersEntry'; }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new HeadersEntry();
+            HeadersEntry.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.key = _instance.key || '';
+            _instance.value = _instance.value || '';
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.key = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.value = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            HeadersEntry.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.key) {
+                _writer.writeString(1, _instance.key);
+            }
+            if (_instance.value) {
+                _writer.writeString(2, _instance.value);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of HeadersEntry to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.key = _value.key;
+            this.value = _value.value;
+            HeadersEntry.refineValues(this);
+        }
+        get key() {
+            return this._key;
+        }
+        set key(value) {
+            this._key = value;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            HeadersEntry.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+    }
+    SipTransferCallRequest.HeadersEntry = HeadersEntry;
+})(SipTransferCallRequest || (SipTransferCallRequest = {}));
+/**
+ * Message implementation for ondewo.sip.SipStatus
+ */
+export class SipStatus {
+    static { this.id = 'ondewo.sip.SipStatus'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipStatus();
+        SipStatus.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.accountName = _instance.accountName || '';
+        _instance.timestamp = _instance.timestamp || undefined;
+        _instance.statusType = _instance.statusType || 0;
+        _instance.calleeId = _instance.calleeId || '';
+        _instance.transferCallId = _instance.transferCallId || '';
+        _instance.headers = _instance.headers || {};
+        _instance.description = _instance.description || '';
+        _instance.exceptionName = _instance.exceptionName || '';
+        _instance.exceptionTraceback = _instance.exceptionTraceback || '';
+        _instance.nluSessionName = _instance.nluSessionName || '';
+    }
+    /**
+     * 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.accountName = _reader.readString();
+                    break;
+                case 2:
+                    _instance.timestamp = new googleProtobuf001.Timestamp();
+                    _reader.readMessage(_instance.timestamp, googleProtobuf001.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.statusType = _reader.readEnum();
+                    break;
+                case 4:
+                    _instance.calleeId = _reader.readString();
+                    break;
+                case 5:
+                    _instance.transferCallId = _reader.readString();
+                    break;
+                case 6:
+                    const msg_6 = {};
+                    _reader.readMessage(msg_6, SipStatus.HeadersEntry.deserializeBinaryFromReader);
+                    _instance.headers = _instance.headers || {};
+                    _instance.headers[msg_6.key] = msg_6.value;
+                    break;
+                case 7:
+                    _instance.description = _reader.readString();
+                    break;
+                case 8:
+                    _instance.exceptionName = _reader.readString();
+                    break;
+                case 9:
+                    _instance.exceptionTraceback = _reader.readString();
+                    break;
+                case 10:
+                    _instance.nluSessionName = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipStatus.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.accountName) {
+            _writer.writeString(1, _instance.accountName);
+        }
+        if (_instance.timestamp) {
+            _writer.writeMessage(2, _instance.timestamp, googleProtobuf001.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.statusType) {
+            _writer.writeEnum(3, _instance.statusType);
+        }
+        if (_instance.calleeId) {
+            _writer.writeString(4, _instance.calleeId);
+        }
+        if (_instance.transferCallId) {
+            _writer.writeString(5, _instance.transferCallId);
+        }
+        if (!!_instance.headers) {
+            const keys_6 = Object.keys(_instance.headers);
+            if (keys_6.length) {
+                const repeated_6 = keys_6
+                    .map(key => ({ key: key, value: _instance.headers[key] }))
+                    .reduce((r, v) => [...r, v], []);
+                _writer.writeRepeatedMessage(6, repeated_6, SipStatus.HeadersEntry.serializeBinaryToWriter);
+            }
+        }
+        if (_instance.description) {
+            _writer.writeString(7, _instance.description);
+        }
+        if (_instance.exceptionName) {
+            _writer.writeString(8, _instance.exceptionName);
+        }
+        if (_instance.exceptionTraceback) {
+            _writer.writeString(9, _instance.exceptionTraceback);
+        }
+        if (_instance.nluSessionName) {
+            _writer.writeString(10, _instance.nluSessionName);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipStatus to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.accountName = _value.accountName;
+        this.timestamp = _value.timestamp
+            ? new googleProtobuf001.Timestamp(_value.timestamp)
+            : undefined;
+        this.statusType = _value.statusType;
+        this.calleeId = _value.calleeId;
+        this.transferCallId = _value.transferCallId;
+        (this.headers = _value.headers
+            ? Object.keys(_value.headers).reduce((r, k) => ({ ...r, [k]: _value.headers[k] }), {})
+            : {}),
+            (this.description = _value.description);
+        this.exceptionName = _value.exceptionName;
+        this.exceptionTraceback = _value.exceptionTraceback;
+        this.nluSessionName = _value.nluSessionName;
+        SipStatus.refineValues(this);
+    }
+    get accountName() {
+        return this._accountName;
+    }
+    set accountName(value) {
+        this._accountName = value;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    set timestamp(value) {
+        this._timestamp = value;
+    }
+    get statusType() {
+        return this._statusType;
+    }
+    set statusType(value) {
+        this._statusType = value;
+    }
+    get calleeId() {
+        return this._calleeId;
+    }
+    set calleeId(value) {
+        this._calleeId = value;
+    }
+    get transferCallId() {
+        return this._transferCallId;
+    }
+    set transferCallId(value) {
+        this._transferCallId = value;
+    }
+    get headers() {
+        return this._headers;
+    }
+    set headers(value) {
+        this._headers = value;
+    }
+    get description() {
+        return this._description;
+    }
+    set description(value) {
+        this._description = value;
+    }
+    get exceptionName() {
+        return this._exceptionName;
+    }
+    set exceptionName(value) {
+        this._exceptionName = value;
+    }
+    get exceptionTraceback() {
+        return this._exceptionTraceback;
+    }
+    set exceptionTraceback(value) {
+        this._exceptionTraceback = value;
+    }
+    get nluSessionName() {
+        return this._nluSessionName;
+    }
+    set nluSessionName(value) {
+        this._nluSessionName = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipStatus.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            accountName: this.accountName,
+            timestamp: this.timestamp ? this.timestamp.toObject() : undefined,
+            statusType: this.statusType,
+            calleeId: this.calleeId,
+            transferCallId: this.transferCallId,
+            headers: this.headers
+                ? Object.keys(this.headers).reduce((r, k) => ({ ...r, [k]: this.headers[k] }), {})
+                : {},
+            description: this.description,
+            exceptionName: this.exceptionName,
+            exceptionTraceback: this.exceptionTraceback,
+            nluSessionName: this.nluSessionName
+        };
+    }
+    /**
+     * 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 {
+            accountName: this.accountName,
+            timestamp: this.timestamp ? this.timestamp.toProtobufJSON(options) : null,
+            statusType: SipStatus.StatusType[this.statusType === null || this.statusType === undefined
+                ? 0
+                : this.statusType],
+            calleeId: this.calleeId,
+            transferCallId: this.transferCallId,
+            headers: this.headers
+                ? Object.keys(this.headers).reduce((r, k) => ({ ...r, [k]: this.headers[k] }), {})
+                : {},
+            description: this.description,
+            exceptionName: this.exceptionName,
+            exceptionTraceback: this.exceptionTraceback,
+            nluSessionName: this.nluSessionName
+        };
+    }
+}
+(function (SipStatus) {
+    let StatusType;
+    (function (StatusType) {
+        StatusType[StatusType["NO_SESSION"] = 0] = "NO_SESSION";
+        StatusType[StatusType["REGISTERED"] = 1] = "REGISTERED";
+        StatusType[StatusType["READY"] = 2] = "READY";
+        StatusType[StatusType["INCOMING_CALL_INITIATED"] = 3] = "INCOMING_CALL_INITIATED";
+        StatusType[StatusType["OUTGOING_CALL_INITIATED"] = 4] = "OUTGOING_CALL_INITIATED";
+        StatusType[StatusType["OUTGOING_CALL_CONNECTED"] = 5] = "OUTGOING_CALL_CONNECTED";
+        StatusType[StatusType["INCOMING_CALL_CONNECTED"] = 6] = "INCOMING_CALL_CONNECTED";
+        StatusType[StatusType["TRANSFER_CALL_INITIATED"] = 7] = "TRANSFER_CALL_INITIATED";
+        StatusType[StatusType["SOFT_HANGUP_INITIATED"] = 8] = "SOFT_HANGUP_INITIATED";
+        StatusType[StatusType["HARD_HANGUP_INITIATED"] = 9] = "HARD_HANGUP_INITIATED";
+        StatusType[StatusType["INCOMING_CALL_FAILED"] = 10] = "INCOMING_CALL_FAILED";
+        StatusType[StatusType["OUTGOING_CALL_FAILED"] = 11] = "OUTGOING_CALL_FAILED";
+        StatusType[StatusType["INCOMING_CALL_FINISHED"] = 12] = "INCOMING_CALL_FINISHED";
+        StatusType[StatusType["OUTGOING_CALL_FINISHED"] = 13] = "OUTGOING_CALL_FINISHED";
+        StatusType[StatusType["SESSION_REGISTRATION_FAILED"] = 14] = "SESSION_REGISTRATION_FAILED";
+        StatusType[StatusType["SESSION_STARTED"] = 15] = "SESSION_STARTED";
+        StatusType[StatusType["SESSION_ENDED"] = 16] = "SESSION_ENDED";
+        StatusType[StatusType["TRANSFER_CALL_FAILED"] = 17] = "TRANSFER_CALL_FAILED";
+        StatusType[StatusType["MICROPHONE_MUTED"] = 18] = "MICROPHONE_MUTED";
+        StatusType[StatusType["MICROPHONE_UNMUTED"] = 19] = "MICROPHONE_UNMUTED";
+        StatusType[StatusType["MICROPHONE_WAV_FILES_PLAYED"] = 20] = "MICROPHONE_WAV_FILES_PLAYED";
+        StatusType[StatusType["NO_ONGOING_CALL"] = 21] = "NO_ONGOING_CALL";
+    })(StatusType = SipStatus.StatusType || (SipStatus.StatusType = {}));
+    /**
+     * Message implementation for ondewo.sip.SipStatus.HeadersEntry
+     */
+    class HeadersEntry {
+        static { this.id = 'ondewo.sip.SipStatus.HeadersEntry'; }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new HeadersEntry();
+            HeadersEntry.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.key = _instance.key || '';
+            _instance.value = _instance.value || '';
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.key = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.value = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            HeadersEntry.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.key) {
+                _writer.writeString(1, _instance.key);
+            }
+            if (_instance.value) {
+                _writer.writeString(2, _instance.value);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of HeadersEntry to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.key = _value.key;
+            this.value = _value.value;
+            HeadersEntry.refineValues(this);
+        }
+        get key() {
+            return this._key;
+        }
+        set key(value) {
+            this._key = value;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            HeadersEntry.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+    }
+    SipStatus.HeadersEntry = HeadersEntry;
+})(SipStatus || (SipStatus = {}));
+/**
+ * Message implementation for ondewo.sip.SipStatusHistoryResponse
+ */
+export class SipStatusHistoryResponse {
+    static { this.id = 'ondewo.sip.SipStatusHistoryResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipStatusHistoryResponse();
+        SipStatusHistoryResponse.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.statusHistory = _instance.statusHistory || [];
+    }
+    /**
+     * 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 SipStatus();
+                    _reader.readMessage(messageInitializer1, SipStatus.deserializeBinaryFromReader);
+                    (_instance.statusHistory = _instance.statusHistory || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipStatusHistoryResponse.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.statusHistory && _instance.statusHistory.length) {
+            _writer.writeRepeatedMessage(1, _instance.statusHistory, SipStatus.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipStatusHistoryResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.statusHistory = (_value.statusHistory || []).map(m => new SipStatus(m));
+        SipStatusHistoryResponse.refineValues(this);
+    }
+    get statusHistory() {
+        return this._statusHistory;
+    }
+    set statusHistory(value) {
+        this._statusHistory = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipStatusHistoryResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            statusHistory: (this.statusHistory || []).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 {
+            statusHistory: (this.statusHistory || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+/**
+ * Message implementation for ondewo.sip.SipPlayWavFilesRequest
+ */
+export class SipPlayWavFilesRequest {
+    static { this.id = 'ondewo.sip.SipPlayWavFilesRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new SipPlayWavFilesRequest();
+        SipPlayWavFilesRequest.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.wavFiles = _instance.wavFiles || [];
+    }
+    /**
+     * 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.wavFiles = _instance.wavFiles || []).push(_reader.readBytes());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        SipPlayWavFilesRequest.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.wavFiles && _instance.wavFiles.length) {
+            _writer.writeRepeatedBytes(1, _instance.wavFiles);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of SipPlayWavFilesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.wavFiles = (_value.wavFiles || []).map(b => b ? b.subarray(0) : new Uint8Array());
+        SipPlayWavFilesRequest.refineValues(this);
+    }
+    get wavFiles() {
+        return this._wavFiles;
+    }
+    set wavFiles(value) {
+        this._wavFiles = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        SipPlayWavFilesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            wavFiles: (this.wavFiles || []).map(b => b ? b.subarray(0) : new Uint8Array())
+        };
+    }
+    /**
+     * 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 {
+            wavFiles: (this.wavFiles || []).map(b => (b ? uint8ArrayToBase64(b) : ''))
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sip.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/sip/sip.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 googleProtobuf001 from '@ngx-grpc/well-known-types';\n/**\n * Message implementation for ondewo.sip.SipEndCallRequest\n */\nexport class SipEndCallRequest implements GrpcMessage {\n  static id = 'ondewo.sip.SipEndCallRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipEndCallRequest();\n    SipEndCallRequest.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: SipEndCallRequest) {\n    _instance.hardHangup = _instance.hardHangup || false;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: SipEndCallRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.hardHangup = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipEndCallRequest.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: SipEndCallRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.hardHangup) {\n      _writer.writeBool(1, _instance.hardHangup);\n    }\n  }\n\n  private _hardHangup: boolean;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SipEndCallRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipEndCallRequest.AsObject>) {\n    _value = _value || {};\n    this.hardHangup = _value.hardHangup;\n    SipEndCallRequest.refineValues(this);\n  }\n  get hardHangup(): boolean {\n    return this._hardHangup;\n  }\n  set hardHangup(value: boolean) {\n    this._hardHangup = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipEndCallRequest.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(): SipEndCallRequest.AsObject {\n    return {\n      hardHangup: this.hardHangup\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  ): SipEndCallRequest.AsProtobufJSON {\n    return {\n      hardHangup: this.hardHangup\n    };\n  }\n}\nexport module SipEndCallRequest {\n  /**\n   * Standard JavaScript object representation for SipEndCallRequest\n   */\n  export interface AsObject {\n    hardHangup: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for SipEndCallRequest\n   */\n  export interface AsProtobufJSON {\n    hardHangup: boolean;\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.SipStartCallRequest\n */\nexport class SipStartCallRequest implements GrpcMessage {\n  static id = 'ondewo.sip.SipStartCallRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipStartCallRequest();\n    SipStartCallRequest.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: SipStartCallRequest) {\n    _instance.calleeId = _instance.calleeId || '';\n    _instance.headers = _instance.headers || {};\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: SipStartCallRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.calleeId = _reader.readString();\n          break;\n        case 2:\n          const msg_2 = {} as any;\n          _reader.readMessage(\n            msg_2,\n            SipStartCallRequest.HeadersEntry.deserializeBinaryFromReader\n          );\n          _instance.headers = _instance.headers || {};\n          _instance.headers[msg_2.key] = msg_2.value;\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipStartCallRequest.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: SipStartCallRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.calleeId) {\n      _writer.writeString(1, _instance.calleeId);\n    }\n    if (!!_instance.headers) {\n      const keys_2 = Object.keys(_instance.headers as any);\n\n      if (keys_2.length) {\n        const repeated_2 = keys_2\n          .map(key => ({ key: key, value: (_instance.headers as any)[key] }))\n          .reduce((r, v) => [...r, v], [] as any[]);\n\n        _writer.writeRepeatedMessage(\n          2,\n          repeated_2,\n          SipStartCallRequest.HeadersEntry.serializeBinaryToWriter\n        );\n      }\n    }\n  }\n\n  private _calleeId: string;\n  private _headers: { [prop: string]: 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 SipStartCallRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipStartCallRequest.AsObject>) {\n    _value = _value || {};\n    this.calleeId = _value.calleeId;\n    (this.headers = _value!.headers\n      ? Object.keys(_value!.headers).reduce(\n          (r, k) => ({ ...r, [k]: _value!.headers![k] }),\n          {}\n        )\n      : {}),\n      SipStartCallRequest.refineValues(this);\n  }\n  get calleeId(): string {\n    return this._calleeId;\n  }\n  set calleeId(value: string) {\n    this._calleeId = value;\n  }\n  get headers(): { [prop: string]: string } {\n    return this._headers;\n  }\n  set headers(value: { [prop: string]: string }) {\n    this._headers = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipStartCallRequest.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(): SipStartCallRequest.AsObject {\n    return {\n      calleeId: this.calleeId,\n      headers: this.headers\n        ? Object.keys(this.headers).reduce(\n            (r, k) => ({ ...r, [k]: this.headers![k] }),\n            {}\n          )\n        : {}\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): SipStartCallRequest.AsProtobufJSON {\n    return {\n      calleeId: this.calleeId,\n      headers: this.headers\n        ? Object.keys(this.headers).reduce(\n            (r, k) => ({ ...r, [k]: this.headers![k] }),\n            {}\n          )\n        : {}\n    };\n  }\n}\nexport module SipStartCallRequest {\n  /**\n   * Standard JavaScript object representation for SipStartCallRequest\n   */\n  export interface AsObject {\n    calleeId: string;\n    headers: { [prop: string]: string };\n  }\n\n  /**\n   * Protobuf JSON representation for SipStartCallRequest\n   */\n  export interface AsProtobufJSON {\n    calleeId: string;\n    headers: { [prop: string]: string };\n  }\n\n  /**\n   * Message implementation for ondewo.sip.SipStartCallRequest.HeadersEntry\n   */\n  export class HeadersEntry implements GrpcMessage {\n    static id = 'ondewo.sip.SipStartCallRequest.HeadersEntry';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new HeadersEntry();\n      HeadersEntry.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: HeadersEntry) {\n      _instance.key = _instance.key || '';\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: HeadersEntry,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.key = _reader.readString();\n            break;\n          case 2:\n            _instance.value = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      HeadersEntry.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: HeadersEntry,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.key) {\n        _writer.writeString(1, _instance.key);\n      }\n      if (_instance.value) {\n        _writer.writeString(2, _instance.value);\n      }\n    }\n\n    private _key: string;\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 HeadersEntry to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<HeadersEntry.AsObject>) {\n      _value = _value || {};\n      this.key = _value.key;\n      this.value = _value.value;\n      HeadersEntry.refineValues(this);\n    }\n    get key(): string {\n      return this._key;\n    }\n    set key(value: string) {\n      this._key = value;\n    }\n    get value(): string {\n      return this._value;\n    }\n    set value(value: string) {\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      HeadersEntry.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(): HeadersEntry.AsObject {\n      return {\n        key: this.key,\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    ): HeadersEntry.AsProtobufJSON {\n      return {\n        key: this.key,\n        value: this.value\n      };\n    }\n  }\n  export module HeadersEntry {\n    /**\n     * Standard JavaScript object representation for HeadersEntry\n     */\n    export interface AsObject {\n      key: string;\n      value: string;\n    }\n\n    /**\n     * Protobuf JSON representation for HeadersEntry\n     */\n    export interface AsProtobufJSON {\n      key: string;\n      value: string;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.SipRegisterAccountRequest\n */\nexport class SipRegisterAccountRequest implements GrpcMessage {\n  static id = 'ondewo.sip.SipRegisterAccountRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipRegisterAccountRequest();\n    SipRegisterAccountRequest.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: SipRegisterAccountRequest) {\n    _instance.accountName = _instance.accountName || '';\n    _instance.password = _instance.password || '';\n    _instance.authUsername = _instance.authUsername || '';\n    _instance.outboundProxy = _instance.outboundProxy || '';\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: SipRegisterAccountRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.accountName = _reader.readString();\n          break;\n        case 2:\n          _instance.password = _reader.readString();\n          break;\n        case 3:\n          _instance.authUsername = _reader.readString();\n          break;\n        case 4:\n          _instance.outboundProxy = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipRegisterAccountRequest.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: SipRegisterAccountRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.accountName) {\n      _writer.writeString(1, _instance.accountName);\n    }\n    if (_instance.password) {\n      _writer.writeString(2, _instance.password);\n    }\n    if (_instance.authUsername) {\n      _writer.writeString(3, _instance.authUsername);\n    }\n    if (_instance.outboundProxy) {\n      _writer.writeString(4, _instance.outboundProxy);\n    }\n  }\n\n  private _accountName: string;\n  private _password: string;\n  private _authUsername: string;\n  private _outboundProxy: 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 SipRegisterAccountRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipRegisterAccountRequest.AsObject>) {\n    _value = _value || {};\n    this.accountName = _value.accountName;\n    this.password = _value.password;\n    this.authUsername = _value.authUsername;\n    this.outboundProxy = _value.outboundProxy;\n    SipRegisterAccountRequest.refineValues(this);\n  }\n  get accountName(): string {\n    return this._accountName;\n  }\n  set accountName(value: string) {\n    this._accountName = value;\n  }\n  get password(): string {\n    return this._password;\n  }\n  set password(value: string) {\n    this._password = value;\n  }\n  get authUsername(): string {\n    return this._authUsername;\n  }\n  set authUsername(value: string) {\n    this._authUsername = value;\n  }\n  get outboundProxy(): string {\n    return this._outboundProxy;\n  }\n  set outboundProxy(value: string) {\n    this._outboundProxy = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipRegisterAccountRequest.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(): SipRegisterAccountRequest.AsObject {\n    return {\n      accountName: this.accountName,\n      password: this.password,\n      authUsername: this.authUsername,\n      outboundProxy: this.outboundProxy\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  ): SipRegisterAccountRequest.AsProtobufJSON {\n    return {\n      accountName: this.accountName,\n      password: this.password,\n      authUsername: this.authUsername,\n      outboundProxy: this.outboundProxy\n    };\n  }\n}\nexport module SipRegisterAccountRequest {\n  /**\n   * Standard JavaScript object representation for SipRegisterAccountRequest\n   */\n  export interface AsObject {\n    accountName: string;\n    password: string;\n    authUsername: string;\n    outboundProxy: string;\n  }\n\n  /**\n   * Protobuf JSON representation for SipRegisterAccountRequest\n   */\n  export interface AsProtobufJSON {\n    accountName: string;\n    password: string;\n    authUsername: string;\n    outboundProxy: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.SipStartSessionRequest\n */\nexport class SipStartSessionRequest implements GrpcMessage {\n  static id = 'ondewo.sip.SipStartSessionRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipStartSessionRequest();\n    SipStartSessionRequest.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: SipStartSessionRequest) {\n    _instance.accountName = _instance.accountName || '';\n    _instance.autoAnswerInterval = _instance.autoAnswerInterval || 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: SipStartSessionRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.accountName = _reader.readString();\n          break;\n        case 2:\n          _instance.autoAnswerInterval = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipStartSessionRequest.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: SipStartSessionRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.accountName) {\n      _writer.writeString(1, _instance.accountName);\n    }\n    if (_instance.autoAnswerInterval) {\n      _writer.writeInt32(2, _instance.autoAnswerInterval);\n    }\n  }\n\n  private _accountName: string;\n  private _autoAnswerInterval: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SipStartSessionRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipStartSessionRequest.AsObject>) {\n    _value = _value || {};\n    this.accountName = _value.accountName;\n    this.autoAnswerInterval = _value.autoAnswerInterval;\n    SipStartSessionRequest.refineValues(this);\n  }\n  get accountName(): string {\n    return this._accountName;\n  }\n  set accountName(value: string) {\n    this._accountName = value;\n  }\n  get autoAnswerInterval(): number {\n    return this._autoAnswerInterval;\n  }\n  set autoAnswerInterval(value: number) {\n    this._autoAnswerInterval = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipStartSessionRequest.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(): SipStartSessionRequest.AsObject {\n    return {\n      accountName: this.accountName,\n      autoAnswerInterval: this.autoAnswerInterval\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  ): SipStartSessionRequest.AsProtobufJSON {\n    return {\n      accountName: this.accountName,\n      autoAnswerInterval: this.autoAnswerInterval\n    };\n  }\n}\nexport module SipStartSessionRequest {\n  /**\n   * Standard JavaScript object representation for SipStartSessionRequest\n   */\n  export interface AsObject {\n    accountName: string;\n    autoAnswerInterval: number;\n  }\n\n  /**\n   * Protobuf JSON representation for SipStartSessionRequest\n   */\n  export interface AsProtobufJSON {\n    accountName: string;\n    autoAnswerInterval: number;\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.SipTransferCallRequest\n */\nexport class SipTransferCallRequest implements GrpcMessage {\n  static id = 'ondewo.sip.SipTransferCallRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipTransferCallRequest();\n    SipTransferCallRequest.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: SipTransferCallRequest) {\n    _instance.transferId = _instance.transferId || '';\n    _instance.headers = _instance.headers || {};\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: SipTransferCallRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.transferId = _reader.readString();\n          break;\n        case 2:\n          const msg_2 = {} as any;\n          _reader.readMessage(\n            msg_2,\n            SipTransferCallRequest.HeadersEntry.deserializeBinaryFromReader\n          );\n          _instance.headers = _instance.headers || {};\n          _instance.headers[msg_2.key] = msg_2.value;\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipTransferCallRequest.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: SipTransferCallRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.transferId) {\n      _writer.writeString(1, _instance.transferId);\n    }\n    if (!!_instance.headers) {\n      const keys_2 = Object.keys(_instance.headers as any);\n\n      if (keys_2.length) {\n        const repeated_2 = keys_2\n          .map(key => ({ key: key, value: (_instance.headers as any)[key] }))\n          .reduce((r, v) => [...r, v], [] as any[]);\n\n        _writer.writeRepeatedMessage(\n          2,\n          repeated_2,\n          SipTransferCallRequest.HeadersEntry.serializeBinaryToWriter\n        );\n      }\n    }\n  }\n\n  private _transferId: string;\n  private _headers: { [prop: string]: 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 SipTransferCallRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipTransferCallRequest.AsObject>) {\n    _value = _value || {};\n    this.transferId = _value.transferId;\n    (this.headers = _value!.headers\n      ? Object.keys(_value!.headers).reduce(\n          (r, k) => ({ ...r, [k]: _value!.headers![k] }),\n          {}\n        )\n      : {}),\n      SipTransferCallRequest.refineValues(this);\n  }\n  get transferId(): string {\n    return this._transferId;\n  }\n  set transferId(value: string) {\n    this._transferId = value;\n  }\n  get headers(): { [prop: string]: string } {\n    return this._headers;\n  }\n  set headers(value: { [prop: string]: string }) {\n    this._headers = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipTransferCallRequest.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(): SipTransferCallRequest.AsObject {\n    return {\n      transferId: this.transferId,\n      headers: this.headers\n        ? Object.keys(this.headers).reduce(\n            (r, k) => ({ ...r, [k]: this.headers![k] }),\n            {}\n          )\n        : {}\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): SipTransferCallRequest.AsProtobufJSON {\n    return {\n      transferId: this.transferId,\n      headers: this.headers\n        ? Object.keys(this.headers).reduce(\n            (r, k) => ({ ...r, [k]: this.headers![k] }),\n            {}\n          )\n        : {}\n    };\n  }\n}\nexport module SipTransferCallRequest {\n  /**\n   * Standard JavaScript object representation for SipTransferCallRequest\n   */\n  export interface AsObject {\n    transferId: string;\n    headers: { [prop: string]: string };\n  }\n\n  /**\n   * Protobuf JSON representation for SipTransferCallRequest\n   */\n  export interface AsProtobufJSON {\n    transferId: string;\n    headers: { [prop: string]: string };\n  }\n\n  /**\n   * Message implementation for ondewo.sip.SipTransferCallRequest.HeadersEntry\n   */\n  export class HeadersEntry implements GrpcMessage {\n    static id = 'ondewo.sip.SipTransferCallRequest.HeadersEntry';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new HeadersEntry();\n      HeadersEntry.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: HeadersEntry) {\n      _instance.key = _instance.key || '';\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: HeadersEntry,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.key = _reader.readString();\n            break;\n          case 2:\n            _instance.value = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      HeadersEntry.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: HeadersEntry,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.key) {\n        _writer.writeString(1, _instance.key);\n      }\n      if (_instance.value) {\n        _writer.writeString(2, _instance.value);\n      }\n    }\n\n    private _key: string;\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 HeadersEntry to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<HeadersEntry.AsObject>) {\n      _value = _value || {};\n      this.key = _value.key;\n      this.value = _value.value;\n      HeadersEntry.refineValues(this);\n    }\n    get key(): string {\n      return this._key;\n    }\n    set key(value: string) {\n      this._key = value;\n    }\n    get value(): string {\n      return this._value;\n    }\n    set value(value: string) {\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      HeadersEntry.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(): HeadersEntry.AsObject {\n      return {\n        key: this.key,\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    ): HeadersEntry.AsProtobufJSON {\n      return {\n        key: this.key,\n        value: this.value\n      };\n    }\n  }\n  export module HeadersEntry {\n    /**\n     * Standard JavaScript object representation for HeadersEntry\n     */\n    export interface AsObject {\n      key: string;\n      value: string;\n    }\n\n    /**\n     * Protobuf JSON representation for HeadersEntry\n     */\n    export interface AsProtobufJSON {\n      key: string;\n      value: string;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.SipStatus\n */\nexport class SipStatus implements GrpcMessage {\n  static id = 'ondewo.sip.SipStatus';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipStatus();\n    SipStatus.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: SipStatus) {\n    _instance.accountName = _instance.accountName || '';\n    _instance.timestamp = _instance.timestamp || undefined;\n    _instance.statusType = _instance.statusType || 0;\n    _instance.calleeId = _instance.calleeId || '';\n    _instance.transferCallId = _instance.transferCallId || '';\n    _instance.headers = _instance.headers || {};\n    _instance.description = _instance.description || '';\n    _instance.exceptionName = _instance.exceptionName || '';\n    _instance.exceptionTraceback = _instance.exceptionTraceback || '';\n    _instance.nluSessionName = _instance.nluSessionName || '';\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: SipStatus,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.accountName = _reader.readString();\n          break;\n        case 2:\n          _instance.timestamp = new googleProtobuf001.Timestamp();\n          _reader.readMessage(\n            _instance.timestamp,\n            googleProtobuf001.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.statusType = _reader.readEnum();\n          break;\n        case 4:\n          _instance.calleeId = _reader.readString();\n          break;\n        case 5:\n          _instance.transferCallId = _reader.readString();\n          break;\n        case 6:\n          const msg_6 = {} as any;\n          _reader.readMessage(\n            msg_6,\n            SipStatus.HeadersEntry.deserializeBinaryFromReader\n          );\n          _instance.headers = _instance.headers || {};\n          _instance.headers[msg_6.key] = msg_6.value;\n          break;\n        case 7:\n          _instance.description = _reader.readString();\n          break;\n        case 8:\n          _instance.exceptionName = _reader.readString();\n          break;\n        case 9:\n          _instance.exceptionTraceback = _reader.readString();\n          break;\n        case 10:\n          _instance.nluSessionName = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipStatus.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: SipStatus, _writer: BinaryWriter) {\n    if (_instance.accountName) {\n      _writer.writeString(1, _instance.accountName);\n    }\n    if (_instance.timestamp) {\n      _writer.writeMessage(\n        2,\n        _instance.timestamp as any,\n        googleProtobuf001.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.statusType) {\n      _writer.writeEnum(3, _instance.statusType);\n    }\n    if (_instance.calleeId) {\n      _writer.writeString(4, _instance.calleeId);\n    }\n    if (_instance.transferCallId) {\n      _writer.writeString(5, _instance.transferCallId);\n    }\n    if (!!_instance.headers) {\n      const keys_6 = Object.keys(_instance.headers as any);\n\n      if (keys_6.length) {\n        const repeated_6 = keys_6\n          .map(key => ({ key: key, value: (_instance.headers as any)[key] }))\n          .reduce((r, v) => [...r, v], [] as any[]);\n\n        _writer.writeRepeatedMessage(\n          6,\n          repeated_6,\n          SipStatus.HeadersEntry.serializeBinaryToWriter\n        );\n      }\n    }\n    if (_instance.description) {\n      _writer.writeString(7, _instance.description);\n    }\n    if (_instance.exceptionName) {\n      _writer.writeString(8, _instance.exceptionName);\n    }\n    if (_instance.exceptionTraceback) {\n      _writer.writeString(9, _instance.exceptionTraceback);\n    }\n    if (_instance.nluSessionName) {\n      _writer.writeString(10, _instance.nluSessionName);\n    }\n  }\n\n  private _accountName: string;\n  private _timestamp?: googleProtobuf001.Timestamp;\n  private _statusType: SipStatus.StatusType;\n  private _calleeId: string;\n  private _transferCallId: string;\n  private _headers: { [prop: string]: string };\n  private _description: string;\n  private _exceptionName: string;\n  private _exceptionTraceback: string;\n  private _nluSessionName: 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 SipStatus to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipStatus.AsObject>) {\n    _value = _value || {};\n    this.accountName = _value.accountName;\n    this.timestamp = _value.timestamp\n      ? new googleProtobuf001.Timestamp(_value.timestamp)\n      : undefined;\n    this.statusType = _value.statusType;\n    this.calleeId = _value.calleeId;\n    this.transferCallId = _value.transferCallId;\n    (this.headers = _value!.headers\n      ? Object.keys(_value!.headers).reduce(\n          (r, k) => ({ ...r, [k]: _value!.headers![k] }),\n          {}\n        )\n      : {}),\n      (this.description = _value.description);\n    this.exceptionName = _value.exceptionName;\n    this.exceptionTraceback = _value.exceptionTraceback;\n    this.nluSessionName = _value.nluSessionName;\n    SipStatus.refineValues(this);\n  }\n  get accountName(): string {\n    return this._accountName;\n  }\n  set accountName(value: string) {\n    this._accountName = value;\n  }\n  get timestamp(): googleProtobuf001.Timestamp | undefined {\n    return this._timestamp;\n  }\n  set timestamp(value: googleProtobuf001.Timestamp | undefined) {\n    this._timestamp = value;\n  }\n  get statusType(): SipStatus.StatusType {\n    return this._statusType;\n  }\n  set statusType(value: SipStatus.StatusType) {\n    this._statusType = value;\n  }\n  get calleeId(): string {\n    return this._calleeId;\n  }\n  set calleeId(value: string) {\n    this._calleeId = value;\n  }\n  get transferCallId(): string {\n    return this._transferCallId;\n  }\n  set transferCallId(value: string) {\n    this._transferCallId = value;\n  }\n  get headers(): { [prop: string]: string } {\n    return this._headers;\n  }\n  set headers(value: { [prop: string]: string }) {\n    this._headers = value;\n  }\n  get description(): string {\n    return this._description;\n  }\n  set description(value: string) {\n    this._description = value;\n  }\n  get exceptionName(): string {\n    return this._exceptionName;\n  }\n  set exceptionName(value: string) {\n    this._exceptionName = value;\n  }\n  get exceptionTraceback(): string {\n    return this._exceptionTraceback;\n  }\n  set exceptionTraceback(value: string) {\n    this._exceptionTraceback = value;\n  }\n  get nluSessionName(): string {\n    return this._nluSessionName;\n  }\n  set nluSessionName(value: string) {\n    this._nluSessionName = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipStatus.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(): SipStatus.AsObject {\n    return {\n      accountName: this.accountName,\n      timestamp: this.timestamp ? this.timestamp.toObject() : undefined,\n      statusType: this.statusType,\n      calleeId: this.calleeId,\n      transferCallId: this.transferCallId,\n      headers: this.headers\n        ? Object.keys(this.headers).reduce(\n            (r, k) => ({ ...r, [k]: this.headers![k] }),\n            {}\n          )\n        : {},\n      description: this.description,\n      exceptionName: this.exceptionName,\n      exceptionTraceback: this.exceptionTraceback,\n      nluSessionName: this.nluSessionName\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  ): SipStatus.AsProtobufJSON {\n    return {\n      accountName: this.accountName,\n      timestamp: this.timestamp ? this.timestamp.toProtobufJSON(options) : null,\n      statusType:\n        SipStatus.StatusType[\n          this.statusType === null || this.statusType === undefined\n            ? 0\n            : this.statusType\n        ],\n      calleeId: this.calleeId,\n      transferCallId: this.transferCallId,\n      headers: this.headers\n        ? Object.keys(this.headers).reduce(\n            (r, k) => ({ ...r, [k]: this.headers![k] }),\n            {}\n          )\n        : {},\n      description: this.description,\n      exceptionName: this.exceptionName,\n      exceptionTraceback: this.exceptionTraceback,\n      nluSessionName: this.nluSessionName\n    };\n  }\n}\nexport module SipStatus {\n  /**\n   * Standard JavaScript object representation for SipStatus\n   */\n  export interface AsObject {\n    accountName: string;\n    timestamp?: googleProtobuf001.Timestamp.AsObject;\n    statusType: SipStatus.StatusType;\n    calleeId: string;\n    transferCallId: string;\n    headers: { [prop: string]: string };\n    description: string;\n    exceptionName: string;\n    exceptionTraceback: string;\n    nluSessionName: string;\n  }\n\n  /**\n   * Protobuf JSON representation for SipStatus\n   */\n  export interface AsProtobufJSON {\n    accountName: string;\n    timestamp: googleProtobuf001.Timestamp.AsProtobufJSON | null;\n    statusType: string;\n    calleeId: string;\n    transferCallId: string;\n    headers: { [prop: string]: string };\n    description: string;\n    exceptionName: string;\n    exceptionTraceback: string;\n    nluSessionName: string;\n  }\n  export enum StatusType {\n    NO_SESSION = 0,\n    REGISTERED = 1,\n    READY = 2,\n    INCOMING_CALL_INITIATED = 3,\n    OUTGOING_CALL_INITIATED = 4,\n    OUTGOING_CALL_CONNECTED = 5,\n    INCOMING_CALL_CONNECTED = 6,\n    TRANSFER_CALL_INITIATED = 7,\n    SOFT_HANGUP_INITIATED = 8,\n    HARD_HANGUP_INITIATED = 9,\n    INCOMING_CALL_FAILED = 10,\n    OUTGOING_CALL_FAILED = 11,\n    INCOMING_CALL_FINISHED = 12,\n    OUTGOING_CALL_FINISHED = 13,\n    SESSION_REGISTRATION_FAILED = 14,\n    SESSION_STARTED = 15,\n    SESSION_ENDED = 16,\n    TRANSFER_CALL_FAILED = 17,\n    MICROPHONE_MUTED = 18,\n    MICROPHONE_UNMUTED = 19,\n    MICROPHONE_WAV_FILES_PLAYED = 20,\n    NO_ONGOING_CALL = 21\n  }\n  /**\n   * Message implementation for ondewo.sip.SipStatus.HeadersEntry\n   */\n  export class HeadersEntry implements GrpcMessage {\n    static id = 'ondewo.sip.SipStatus.HeadersEntry';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new HeadersEntry();\n      HeadersEntry.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: HeadersEntry) {\n      _instance.key = _instance.key || '';\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: HeadersEntry,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.key = _reader.readString();\n            break;\n          case 2:\n            _instance.value = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      HeadersEntry.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: HeadersEntry,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.key) {\n        _writer.writeString(1, _instance.key);\n      }\n      if (_instance.value) {\n        _writer.writeString(2, _instance.value);\n      }\n    }\n\n    private _key: string;\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 HeadersEntry to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<HeadersEntry.AsObject>) {\n      _value = _value || {};\n      this.key = _value.key;\n      this.value = _value.value;\n      HeadersEntry.refineValues(this);\n    }\n    get key(): string {\n      return this._key;\n    }\n    set key(value: string) {\n      this._key = value;\n    }\n    get value(): string {\n      return this._value;\n    }\n    set value(value: string) {\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      HeadersEntry.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(): HeadersEntry.AsObject {\n      return {\n        key: this.key,\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    ): HeadersEntry.AsProtobufJSON {\n      return {\n        key: this.key,\n        value: this.value\n      };\n    }\n  }\n  export module HeadersEntry {\n    /**\n     * Standard JavaScript object representation for HeadersEntry\n     */\n    export interface AsObject {\n      key: string;\n      value: string;\n    }\n\n    /**\n     * Protobuf JSON representation for HeadersEntry\n     */\n    export interface AsProtobufJSON {\n      key: string;\n      value: string;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.SipStatusHistoryResponse\n */\nexport class SipStatusHistoryResponse implements GrpcMessage {\n  static id = 'ondewo.sip.SipStatusHistoryResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipStatusHistoryResponse();\n    SipStatusHistoryResponse.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: SipStatusHistoryResponse) {\n    _instance.statusHistory = _instance.statusHistory || [];\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: SipStatusHistoryResponse,\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 SipStatus();\n          _reader.readMessage(\n            messageInitializer1,\n            SipStatus.deserializeBinaryFromReader\n          );\n          (_instance.statusHistory = _instance.statusHistory || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipStatusHistoryResponse.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: SipStatusHistoryResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.statusHistory && _instance.statusHistory.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.statusHistory as any,\n        SipStatus.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _statusHistory?: SipStatus[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SipStatusHistoryResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipStatusHistoryResponse.AsObject>) {\n    _value = _value || {};\n    this.statusHistory = (_value.statusHistory || []).map(\n      m => new SipStatus(m)\n    );\n    SipStatusHistoryResponse.refineValues(this);\n  }\n  get statusHistory(): SipStatus[] | undefined {\n    return this._statusHistory;\n  }\n  set statusHistory(value: SipStatus[] | undefined) {\n    this._statusHistory = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipStatusHistoryResponse.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(): SipStatusHistoryResponse.AsObject {\n    return {\n      statusHistory: (this.statusHistory || []).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  ): SipStatusHistoryResponse.AsProtobufJSON {\n    return {\n      statusHistory: (this.statusHistory || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module SipStatusHistoryResponse {\n  /**\n   * Standard JavaScript object representation for SipStatusHistoryResponse\n   */\n  export interface AsObject {\n    statusHistory?: SipStatus.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for SipStatusHistoryResponse\n   */\n  export interface AsProtobufJSON {\n    statusHistory: SipStatus.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.SipPlayWavFilesRequest\n */\nexport class SipPlayWavFilesRequest implements GrpcMessage {\n  static id = 'ondewo.sip.SipPlayWavFilesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new SipPlayWavFilesRequest();\n    SipPlayWavFilesRequest.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: SipPlayWavFilesRequest) {\n    _instance.wavFiles = _instance.wavFiles || [];\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: SipPlayWavFilesRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.wavFiles = _instance.wavFiles || []).push(\n            _reader.readBytes()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    SipPlayWavFilesRequest.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: SipPlayWavFilesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.wavFiles && _instance.wavFiles.length) {\n      _writer.writeRepeatedBytes(1, _instance.wavFiles);\n    }\n  }\n\n  private _wavFiles: Uint8Array[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of SipPlayWavFilesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<SipPlayWavFilesRequest.AsObject>) {\n    _value = _value || {};\n    this.wavFiles = (_value.wavFiles || []).map(b =>\n      b ? b.subarray(0) : new Uint8Array()\n    );\n    SipPlayWavFilesRequest.refineValues(this);\n  }\n  get wavFiles(): Uint8Array[] {\n    return this._wavFiles;\n  }\n  set wavFiles(value: Uint8Array[]) {\n    this._wavFiles = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    SipPlayWavFilesRequest.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(): SipPlayWavFilesRequest.AsObject {\n    return {\n      wavFiles: (this.wavFiles || []).map(b =>\n        b ? b.subarray(0) : new Uint8Array()\n      )\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): SipPlayWavFilesRequest.AsProtobufJSON {\n    return {\n      wavFiles: (this.wavFiles || []).map(b => (b ? uint8ArrayToBase64(b) : ''))\n    };\n  }\n}\nexport module SipPlayWavFilesRequest {\n  /**\n   * Standard JavaScript object representation for SipPlayWavFilesRequest\n   */\n  export interface AsObject {\n    wavFiles: Uint8Array[];\n  }\n\n  /**\n   * Protobuf JSON representation for SipPlayWavFilesRequest\n   */\n  export interface AsProtobufJSON {\n    wavFiles: string[];\n  }\n}\n"]}