@ondewo/sip-client-angular 3.1.0

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

@@ -0,0 +1,1391 @@
+/* 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.EndCallRequest
+ */
+export class EndCallRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of EndCallRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.hardHangup = _value.hardHangup;
+        EndCallRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new EndCallRequest();
+        EndCallRequest.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();
+            }
+        }
+        EndCallRequest.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);
+        }
+    }
+    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();
+        EndCallRequest.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
+        };
+    }
+}
+EndCallRequest.id = 'ondewo.sip.EndCallRequest';
+/**
+ * Message implementation for ondewo.sip.StartCallRequest
+ */
+export class StartCallRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of StartCallRequest 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] }), {})
+            : {}),
+            StartCallRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new StartCallRequest();
+        StartCallRequest.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, StartCallRequest.HeadersEntry.deserializeBinaryFromReader);
+                    _instance.headers = _instance.headers || {};
+                    _instance.headers[msg_2.key] = msg_2.value;
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        StartCallRequest.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, StartCallRequest.HeadersEntry.serializeBinaryToWriter);
+            }
+        }
+    }
+    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();
+        StartCallRequest.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] }), {})
+                : {}
+        };
+    }
+}
+StartCallRequest.id = 'ondewo.sip.StartCallRequest';
+(function (StartCallRequest) {
+    /**
+     * Message implementation for ondewo.sip.HeadersEntry
+     */
+    class HeadersEntry {
+        /**
+         * 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);
+        }
+        /**
+         * 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);
+            }
+        }
+        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
+            };
+        }
+    }
+    HeadersEntry.id = 'ondewo.sip.HeadersEntry';
+    StartCallRequest.HeadersEntry = HeadersEntry;
+})(StartCallRequest || (StartCallRequest = {}));
+/**
+ * Message implementation for ondewo.sip.RegisterAccountRequest
+ */
+export class RegisterAccountRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of RegisterAccountRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.accountName = _value.accountName;
+        this.password = _value.password;
+        RegisterAccountRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new RegisterAccountRequest();
+        RegisterAccountRequest.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 || '';
+    }
+    /**
+     * 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;
+                default:
+                    _reader.skipField();
+            }
+        }
+        RegisterAccountRequest.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);
+        }
+    }
+    get accountName() {
+        return this._accountName;
+    }
+    set accountName(value) {
+        this._accountName = value;
+    }
+    get password() {
+        return this._password;
+    }
+    set password(value) {
+        this._password = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        RegisterAccountRequest.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
+        };
+    }
+    /**
+     * 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
+        };
+    }
+}
+RegisterAccountRequest.id = 'ondewo.sip.RegisterAccountRequest';
+/**
+ * Message implementation for ondewo.sip.StartSessionRequest
+ */
+export class StartSessionRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of StartSessionRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.accountName = _value.accountName;
+        this.autoAnswerInterval = _value.autoAnswerInterval;
+        StartSessionRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new StartSessionRequest();
+        StartSessionRequest.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();
+            }
+        }
+        StartSessionRequest.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);
+        }
+    }
+    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();
+        StartSessionRequest.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
+        };
+    }
+}
+StartSessionRequest.id = 'ondewo.sip.StartSessionRequest';
+/**
+ * Message implementation for ondewo.sip.TransferCallRequest
+ */
+export class TransferCallRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TransferCallRequest 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] }), {})
+            : {}),
+            TransferCallRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TransferCallRequest();
+        TransferCallRequest.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, TransferCallRequest.HeadersEntry.deserializeBinaryFromReader);
+                    _instance.headers = _instance.headers || {};
+                    _instance.headers[msg_2.key] = msg_2.value;
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TransferCallRequest.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, TransferCallRequest.HeadersEntry.serializeBinaryToWriter);
+            }
+        }
+    }
+    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();
+        TransferCallRequest.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] }), {})
+                : {}
+        };
+    }
+}
+TransferCallRequest.id = 'ondewo.sip.TransferCallRequest';
+(function (TransferCallRequest) {
+    /**
+     * Message implementation for ondewo.sip.HeadersEntry
+     */
+    class HeadersEntry {
+        /**
+         * 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);
+        }
+        /**
+         * 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);
+            }
+        }
+        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
+            };
+        }
+    }
+    HeadersEntry.id = 'ondewo.sip.HeadersEntry';
+    TransferCallRequest.HeadersEntry = HeadersEntry;
+})(TransferCallRequest || (TransferCallRequest = {}));
+/**
+ * Message implementation for ondewo.sip.SipStatus
+ */
+export class SipStatus {
+    /**
+     * 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] }), {})
+            : {}),
+            SipStatus.refineValues(this);
+    }
+    /**
+     * 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 || {};
+    }
+    /**
+     * 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;
+                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);
+            }
+        }
+    }
+    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;
+    }
+    /**
+     * 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] }), {})
+                : {}
+        };
+    }
+    /**
+     * 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] }), {})
+                : {}
+        };
+    }
+}
+SipStatus.id = 'ondewo.sip.SipStatus';
+(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 = SipStatus.StatusType || (SipStatus.StatusType = {}));
+    /**
+     * Message implementation for ondewo.sip.HeadersEntry
+     */
+    class HeadersEntry {
+        /**
+         * 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);
+        }
+        /**
+         * 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);
+            }
+        }
+        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
+            };
+        }
+    }
+    HeadersEntry.id = 'ondewo.sip.HeadersEntry';
+    SipStatus.HeadersEntry = HeadersEntry;
+})(SipStatus || (SipStatus = {}));
+/**
+ * Message implementation for ondewo.sip.SipStatusHistoryResponse
+ */
+export class SipStatusHistoryResponse {
+    /**
+     * 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);
+    }
+    /**
+     * 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);
+        }
+    }
+    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))
+        };
+    }
+}
+SipStatusHistoryResponse.id = 'ondewo.sip.SipStatusHistoryResponse';
+/**
+ * Message implementation for ondewo.sip.PlayWavFilesRequest
+ */
+export class PlayWavFilesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of PlayWavFilesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.wavFiles = (_value.wavFiles || []).map(b => b ? b.subarray(0) : new Uint8Array());
+        PlayWavFilesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new PlayWavFilesRequest();
+        PlayWavFilesRequest.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();
+            }
+        }
+        PlayWavFilesRequest.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);
+        }
+    }
+    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();
+        PlayWavFilesRequest.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) : ''))
+        };
+    }
+}
+PlayWavFilesRequest.id = 'ondewo.sip.PlayWavFilesRequest';
+//# 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.EndCallRequest\n */\nexport class EndCallRequest implements GrpcMessage {\n  static id = 'ondewo.sip.EndCallRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new EndCallRequest();\n    EndCallRequest.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: EndCallRequest) {\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: EndCallRequest,\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    EndCallRequest.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: EndCallRequest,\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 EndCallRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<EndCallRequest.AsObject>) {\n    _value = _value || {};\n    this.hardHangup = _value.hardHangup;\n    EndCallRequest.refineValues(this);\n  }\n  get hardHangup(): boolean | undefined {\n    return this._hardHangup;\n  }\n  set hardHangup(value: boolean | undefined) {\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    EndCallRequest.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(): EndCallRequest.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  ): EndCallRequest.AsProtobufJSON {\n    return {\n      hardHangup: this.hardHangup\n    };\n  }\n}\nexport module EndCallRequest {\n  /**\n   * Standard JavaScript object representation for EndCallRequest\n   */\n  export interface AsObject {\n    hardHangup?: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for EndCallRequest\n   */\n  export interface AsProtobufJSON {\n    hardHangup?: boolean;\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.StartCallRequest\n */\nexport class StartCallRequest implements GrpcMessage {\n  static id = 'ondewo.sip.StartCallRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new StartCallRequest();\n    StartCallRequest.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: StartCallRequest) {\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: StartCallRequest,\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            StartCallRequest.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    StartCallRequest.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: StartCallRequest,\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          StartCallRequest.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 StartCallRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<StartCallRequest.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      StartCallRequest.refineValues(this);\n  }\n  get calleeId(): string | undefined {\n    return this._calleeId;\n  }\n  set calleeId(value: string | undefined) {\n    this._calleeId = value;\n  }\n  get headers(): { [prop: string]: string } | undefined {\n    return this._headers;\n  }\n  set headers(value: { [prop: string]: string } | undefined) {\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    StartCallRequest.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(): StartCallRequest.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  ): StartCallRequest.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 StartCallRequest {\n  /**\n   * Standard JavaScript object representation for StartCallRequest\n   */\n  export interface AsObject {\n    calleeId?: string;\n    headers?: { [prop: string]: string };\n  }\n\n  /**\n   * Protobuf JSON representation for StartCallRequest\n   */\n  export interface AsProtobufJSON {\n    calleeId?: string;\n    headers?: { [prop: string]: string };\n  }\n\n  /**\n   * Message implementation for ondewo.sip.HeadersEntry\n   */\n  export class HeadersEntry implements GrpcMessage {\n    static id = 'ondewo.sip.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 | undefined {\n      return this._key;\n    }\n    set key(value: string | undefined) {\n      this._key = value;\n    }\n    get value(): string | undefined {\n      return this._value;\n    }\n    set value(value: string | undefined) {\n      this._value = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      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.RegisterAccountRequest\n */\nexport class RegisterAccountRequest implements GrpcMessage {\n  static id = 'ondewo.sip.RegisterAccountRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new RegisterAccountRequest();\n    RegisterAccountRequest.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: RegisterAccountRequest) {\n    _instance.accountName = _instance.accountName || '';\n    _instance.password = _instance.password || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: RegisterAccountRequest,\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        default:\n          _reader.skipField();\n      }\n    }\n\n    RegisterAccountRequest.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: RegisterAccountRequest,\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  }\n\n  private _accountName?: string;\n  private _password?: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of RegisterAccountRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<RegisterAccountRequest.AsObject>) {\n    _value = _value || {};\n    this.accountName = _value.accountName;\n    this.password = _value.password;\n    RegisterAccountRequest.refineValues(this);\n  }\n  get accountName(): string | undefined {\n    return this._accountName;\n  }\n  set accountName(value: string | undefined) {\n    this._accountName = value;\n  }\n  get password(): string | undefined {\n    return this._password;\n  }\n  set password(value: string | undefined) {\n    this._password = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    RegisterAccountRequest.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(): RegisterAccountRequest.AsObject {\n    return {\n      accountName: this.accountName,\n      password: this.password\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): RegisterAccountRequest.AsProtobufJSON {\n    return {\n      accountName: this.accountName,\n      password: this.password\n    };\n  }\n}\nexport module RegisterAccountRequest {\n  /**\n   * Standard JavaScript object representation for RegisterAccountRequest\n   */\n  export interface AsObject {\n    accountName?: string;\n    password?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for RegisterAccountRequest\n   */\n  export interface AsProtobufJSON {\n    accountName?: string;\n    password?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.StartSessionRequest\n */\nexport class StartSessionRequest implements GrpcMessage {\n  static id = 'ondewo.sip.StartSessionRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new StartSessionRequest();\n    StartSessionRequest.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: StartSessionRequest) {\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: StartSessionRequest,\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    StartSessionRequest.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: StartSessionRequest,\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 StartSessionRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<StartSessionRequest.AsObject>) {\n    _value = _value || {};\n    this.accountName = _value.accountName;\n    this.autoAnswerInterval = _value.autoAnswerInterval;\n    StartSessionRequest.refineValues(this);\n  }\n  get accountName(): string | undefined {\n    return this._accountName;\n  }\n  set accountName(value: string | undefined) {\n    this._accountName = value;\n  }\n  get autoAnswerInterval(): number | undefined {\n    return this._autoAnswerInterval;\n  }\n  set autoAnswerInterval(value: number | undefined) {\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    StartSessionRequest.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(): StartSessionRequest.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  ): StartSessionRequest.AsProtobufJSON {\n    return {\n      accountName: this.accountName,\n      autoAnswerInterval: this.autoAnswerInterval\n    };\n  }\n}\nexport module StartSessionRequest {\n  /**\n   * Standard JavaScript object representation for StartSessionRequest\n   */\n  export interface AsObject {\n    accountName?: string;\n    autoAnswerInterval?: number;\n  }\n\n  /**\n   * Protobuf JSON representation for StartSessionRequest\n   */\n  export interface AsProtobufJSON {\n    accountName?: string;\n    autoAnswerInterval?: number;\n  }\n}\n\n/**\n * Message implementation for ondewo.sip.TransferCallRequest\n */\nexport class TransferCallRequest implements GrpcMessage {\n  static id = 'ondewo.sip.TransferCallRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TransferCallRequest();\n    TransferCallRequest.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: TransferCallRequest) {\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: TransferCallRequest,\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            TransferCallRequest.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    TransferCallRequest.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: TransferCallRequest,\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          TransferCallRequest.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 TransferCallRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TransferCallRequest.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      TransferCallRequest.refineValues(this);\n  }\n  get transferId(): string | undefined {\n    return this._transferId;\n  }\n  set transferId(value: string | undefined) {\n    this._transferId = value;\n  }\n  get headers(): { [prop: string]: string } | undefined {\n    return this._headers;\n  }\n  set headers(value: { [prop: string]: string } | undefined) {\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    TransferCallRequest.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(): TransferCallRequest.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  ): TransferCallRequest.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 TransferCallRequest {\n  /**\n   * Standard JavaScript object representation for TransferCallRequest\n   */\n  export interface AsObject {\n    transferId?: string;\n    headers?: { [prop: string]: string };\n  }\n\n  /**\n   * Protobuf JSON representation for TransferCallRequest\n   */\n  export interface AsProtobufJSON {\n    transferId?: string;\n    headers?: { [prop: string]: string };\n  }\n\n  /**\n   * Message implementation for ondewo.sip.HeadersEntry\n   */\n  export class HeadersEntry implements GrpcMessage {\n    static id = 'ondewo.sip.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 | undefined {\n      return this._key;\n    }\n    set key(value: string | undefined) {\n      this._key = value;\n    }\n    get value(): string | undefined {\n      return this._value;\n    }\n    set value(value: string | undefined) {\n      this._value = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      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  }\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        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  }\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\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      SipStatus.refineValues(this);\n  }\n  get accountName(): string | undefined {\n    return this._accountName;\n  }\n  set accountName(value: string | undefined) {\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 | undefined {\n    return this._statusType;\n  }\n  set statusType(value: SipStatus.StatusType | undefined) {\n    this._statusType = value;\n  }\n  get calleeId(): string | undefined {\n    return this._calleeId;\n  }\n  set calleeId(value: string | undefined) {\n    this._calleeId = value;\n  }\n  get transferCallId(): string | undefined {\n    return this._transferCallId;\n  }\n  set transferCallId(value: string | undefined) {\n    this._transferCallId = value;\n  }\n  get headers(): { [prop: string]: string } | undefined {\n    return this._headers;\n  }\n  set headers(value: { [prop: string]: string } | undefined) {\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    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    };\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    };\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  }\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  }\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  }\n  /**\n   * Message implementation for ondewo.sip.HeadersEntry\n   */\n  export class HeadersEntry implements GrpcMessage {\n    static id = 'ondewo.sip.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 | undefined {\n      return this._key;\n    }\n    set key(value: string | undefined) {\n      this._key = value;\n    }\n    get value(): string | undefined {\n      return this._value;\n    }\n    set value(value: string | undefined) {\n      this._value = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      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.PlayWavFilesRequest\n */\nexport class PlayWavFilesRequest implements GrpcMessage {\n  static id = 'ondewo.sip.PlayWavFilesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new PlayWavFilesRequest();\n    PlayWavFilesRequest.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: PlayWavFilesRequest) {\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: PlayWavFilesRequest,\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    PlayWavFilesRequest.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: PlayWavFilesRequest,\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 PlayWavFilesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<PlayWavFilesRequest.AsObject>) {\n    _value = _value || {};\n    this.wavFiles = (_value.wavFiles || []).map(b =>\n      b ? b.subarray(0) : new Uint8Array()\n    );\n    PlayWavFilesRequest.refineValues(this);\n  }\n  get wavFiles(): Uint8Array[] | undefined {\n    return this._wavFiles;\n  }\n  set wavFiles(value: Uint8Array[] | undefined) {\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    PlayWavFilesRequest.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(): PlayWavFilesRequest.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  ): PlayWavFilesRequest.AsProtobufJSON {\n    return {\n      wavFiles: (this.wavFiles || []).map(b => (b ? uint8ArrayToBase64(b) : ''))\n    };\n  }\n}\nexport module PlayWavFilesRequest {\n  /**\n   * Standard JavaScript object representation for PlayWavFilesRequest\n   */\n  export interface AsObject {\n    wavFiles?: Uint8Array[];\n  }\n\n  /**\n   * Protobuf JSON representation for PlayWavFilesRequest\n   */\n  export interface AsProtobufJSON {\n    wavFiles?: string[];\n  }\n}\n"]}