/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
import * as $protobuf from "protobufjs/minimal";

// Common aliases
const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;

// Exported root namespace
const $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});

export const com_list = $root.com_list = (() => {

    /**
     * Properties of a com_list.
     * @exports Icom_list
     * @interface Icom_list
     * @property {Array.<Icom_info>|null} [com] com_list com
     */

    /**
     * Constructs a new com_list.
     * @exports com_list
     * @classdesc Represents a com_list.
     * @implements Icom_list
     * @constructor
     * @param {Icom_list=} [properties] Properties to set
     */
    function com_list(properties) {
        this.com = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * com_list com.
     * @member {Array.<Icom_info>} com
     * @memberof com_list
     * @instance
     */
    com_list.prototype.com = $util.emptyArray;

    /**
     * Creates a new com_list instance using the specified properties.
     * @function create
     * @memberof com_list
     * @static
     * @param {Icom_list=} [properties] Properties to set
     * @returns {com_list} com_list instance
     */
    com_list.create = function create(properties) {
        return new com_list(properties);
    };

    /**
     * Encodes the specified com_list message. Does not implicitly {@link com_list.verify|verify} messages.
     * @function encode
     * @memberof com_list
     * @static
     * @param {Icom_list} message com_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    com_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.com != null && message.com.length)
            for (let i = 0; i < message.com.length; ++i)
                $root.com_info.encode(message.com[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified com_list message, length delimited. Does not implicitly {@link com_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof com_list
     * @static
     * @param {Icom_list} message com_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    com_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a com_list message from the specified reader or buffer.
     * @function decode
     * @memberof com_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {com_list} com_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    com_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.com_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.com && message.com.length))
                        message.com = [];
                    message.com.push($root.com_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a com_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof com_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {com_list} com_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    com_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a com_list message.
     * @function verify
     * @memberof com_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    com_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.com != null && message.hasOwnProperty("com")) {
            if (!Array.isArray(message.com))
                return "com: array expected";
            for (let i = 0; i < message.com.length; ++i) {
                let error = $root.com_info.verify(message.com[i]);
                if (error)
                    return "com." + error;
            }
        }
        return null;
    };

    /**
     * Creates a com_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof com_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {com_list} com_list
     */
    com_list.fromObject = function fromObject(object) {
        if (object instanceof $root.com_list)
            return object;
        let message = new $root.com_list();
        if (object.com) {
            if (!Array.isArray(object.com))
                throw TypeError(".com_list.com: array expected");
            message.com = [];
            for (let i = 0; i < object.com.length; ++i) {
                if (typeof object.com[i] !== "object")
                    throw TypeError(".com_list.com: object expected");
                message.com[i] = $root.com_info.fromObject(object.com[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a com_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof com_list
     * @static
     * @param {com_list} message com_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    com_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.com = [];
        if (message.com && message.com.length) {
            object.com = [];
            for (let j = 0; j < message.com.length; ++j)
                object.com[j] = $root.com_info.toObject(message.com[j], options);
        }
        return object;
    };

    /**
     * Converts this com_list to JSON.
     * @function toJSON
     * @memberof com_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    com_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for com_list
     * @function getTypeUrl
     * @memberof com_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    com_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/com_list";
    };

    return com_list;
})();

export const com_info = $root.com_info = (() => {

    /**
     * Properties of a com_info.
     * @exports Icom_info
     * @interface Icom_info
     * @property {string|null} [name] com_info name
     * @property {string|null} [path] com_info path
     * @property {boolean|null} [used] com_info used
     * @property {number|null} [baudRate] com_info baudRate
     * @property {number|null} [dataBits] com_info dataBits
     * @property {number|null} [stopBits] com_info stopBits
     * @property {string|null} [parity] com_info parity
     * @property {number|null} [timeout] com_info timeout
     */

    /**
     * Constructs a new com_info.
     * @exports com_info
     * @classdesc Represents a com_info.
     * @implements Icom_info
     * @constructor
     * @param {Icom_info=} [properties] Properties to set
     */
    function com_info(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * com_info name.
     * @member {string} name
     * @memberof com_info
     * @instance
     */
    com_info.prototype.name = "";

    /**
     * com_info path.
     * @member {string} path
     * @memberof com_info
     * @instance
     */
    com_info.prototype.path = "";

    /**
     * com_info used.
     * @member {boolean} used
     * @memberof com_info
     * @instance
     */
    com_info.prototype.used = false;

    /**
     * com_info baudRate.
     * @member {number} baudRate
     * @memberof com_info
     * @instance
     */
    com_info.prototype.baudRate = 0;

    /**
     * com_info dataBits.
     * @member {number} dataBits
     * @memberof com_info
     * @instance
     */
    com_info.prototype.dataBits = 0;

    /**
     * com_info stopBits.
     * @member {number} stopBits
     * @memberof com_info
     * @instance
     */
    com_info.prototype.stopBits = 0;

    /**
     * com_info parity.
     * @member {string} parity
     * @memberof com_info
     * @instance
     */
    com_info.prototype.parity = "";

    /**
     * com_info timeout.
     * @member {number} timeout
     * @memberof com_info
     * @instance
     */
    com_info.prototype.timeout = 0;

    /**
     * Creates a new com_info instance using the specified properties.
     * @function create
     * @memberof com_info
     * @static
     * @param {Icom_info=} [properties] Properties to set
     * @returns {com_info} com_info instance
     */
    com_info.create = function create(properties) {
        return new com_info(properties);
    };

    /**
     * Encodes the specified com_info message. Does not implicitly {@link com_info.verify|verify} messages.
     * @function encode
     * @memberof com_info
     * @static
     * @param {Icom_info} message com_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    com_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.path != null && Object.hasOwnProperty.call(message, "path"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.path);
        if (message.used != null && Object.hasOwnProperty.call(message, "used"))
            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.used);
        if (message.baudRate != null && Object.hasOwnProperty.call(message, "baudRate"))
            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.baudRate);
        if (message.dataBits != null && Object.hasOwnProperty.call(message, "dataBits"))
            writer.uint32(/* id 5, wireType 0 =*/40).int32(message.dataBits);
        if (message.stopBits != null && Object.hasOwnProperty.call(message, "stopBits"))
            writer.uint32(/* id 6, wireType 0 =*/48).int32(message.stopBits);
        if (message.parity != null && Object.hasOwnProperty.call(message, "parity"))
            writer.uint32(/* id 7, wireType 2 =*/58).string(message.parity);
        if (message.timeout != null && Object.hasOwnProperty.call(message, "timeout"))
            writer.uint32(/* id 8, wireType 0 =*/64).int32(message.timeout);
        return writer;
    };

    /**
     * Encodes the specified com_info message, length delimited. Does not implicitly {@link com_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof com_info
     * @static
     * @param {Icom_info} message com_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    com_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a com_info message from the specified reader or buffer.
     * @function decode
     * @memberof com_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {com_info} com_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    com_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.com_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.path = reader.string();
                    break;
                }
            case 3: {
                    message.used = reader.bool();
                    break;
                }
            case 4: {
                    message.baudRate = reader.int32();
                    break;
                }
            case 5: {
                    message.dataBits = reader.int32();
                    break;
                }
            case 6: {
                    message.stopBits = reader.int32();
                    break;
                }
            case 7: {
                    message.parity = reader.string();
                    break;
                }
            case 8: {
                    message.timeout = reader.int32();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a com_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof com_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {com_info} com_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    com_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a com_info message.
     * @function verify
     * @memberof com_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    com_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.path != null && message.hasOwnProperty("path"))
            if (!$util.isString(message.path))
                return "path: string expected";
        if (message.used != null && message.hasOwnProperty("used"))
            if (typeof message.used !== "boolean")
                return "used: boolean expected";
        if (message.baudRate != null && message.hasOwnProperty("baudRate"))
            if (!$util.isInteger(message.baudRate))
                return "baudRate: integer expected";
        if (message.dataBits != null && message.hasOwnProperty("dataBits"))
            if (!$util.isInteger(message.dataBits))
                return "dataBits: integer expected";
        if (message.stopBits != null && message.hasOwnProperty("stopBits"))
            if (!$util.isInteger(message.stopBits))
                return "stopBits: integer expected";
        if (message.parity != null && message.hasOwnProperty("parity"))
            if (!$util.isString(message.parity))
                return "parity: string expected";
        if (message.timeout != null && message.hasOwnProperty("timeout"))
            if (!$util.isInteger(message.timeout))
                return "timeout: integer expected";
        return null;
    };

    /**
     * Creates a com_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof com_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {com_info} com_info
     */
    com_info.fromObject = function fromObject(object) {
        if (object instanceof $root.com_info)
            return object;
        let message = new $root.com_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.path != null)
            message.path = String(object.path);
        if (object.used != null)
            message.used = Boolean(object.used);
        if (object.baudRate != null)
            message.baudRate = object.baudRate | 0;
        if (object.dataBits != null)
            message.dataBits = object.dataBits | 0;
        if (object.stopBits != null)
            message.stopBits = object.stopBits | 0;
        if (object.parity != null)
            message.parity = String(object.parity);
        if (object.timeout != null)
            message.timeout = object.timeout | 0;
        return message;
    };

    /**
     * Creates a plain object from a com_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof com_info
     * @static
     * @param {com_info} message com_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    com_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.path = "";
            object.used = false;
            object.baudRate = 0;
            object.dataBits = 0;
            object.stopBits = 0;
            object.parity = "";
            object.timeout = 0;
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.path != null && message.hasOwnProperty("path"))
            object.path = message.path;
        if (message.used != null && message.hasOwnProperty("used"))
            object.used = message.used;
        if (message.baudRate != null && message.hasOwnProperty("baudRate"))
            object.baudRate = message.baudRate;
        if (message.dataBits != null && message.hasOwnProperty("dataBits"))
            object.dataBits = message.dataBits;
        if (message.stopBits != null && message.hasOwnProperty("stopBits"))
            object.stopBits = message.stopBits;
        if (message.parity != null && message.hasOwnProperty("parity"))
            object.parity = message.parity;
        if (message.timeout != null && message.hasOwnProperty("timeout"))
            object.timeout = message.timeout;
        return object;
    };

    /**
     * Converts this com_info to JSON.
     * @function toJSON
     * @memberof com_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    com_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for com_info
     * @function getTypeUrl
     * @memberof com_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    com_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/com_info";
    };

    return com_info;
})();

export const m_properties = $root.m_properties = (() => {

    /**
     * Properties of a m_properties.
     * @exports Im_properties
     * @interface Im_properties
     * @property {string|null} [name] m_properties name
     * @property {string|null} [value] m_properties value
     */

    /**
     * Constructs a new m_properties.
     * @exports m_properties
     * @classdesc Represents a m_properties.
     * @implements Im_properties
     * @constructor
     * @param {Im_properties=} [properties] Properties to set
     */
    function m_properties(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * m_properties name.
     * @member {string} name
     * @memberof m_properties
     * @instance
     */
    m_properties.prototype.name = "";

    /**
     * m_properties value.
     * @member {string} value
     * @memberof m_properties
     * @instance
     */
    m_properties.prototype.value = "";

    /**
     * Creates a new m_properties instance using the specified properties.
     * @function create
     * @memberof m_properties
     * @static
     * @param {Im_properties=} [properties] Properties to set
     * @returns {m_properties} m_properties instance
     */
    m_properties.create = function create(properties) {
        return new m_properties(properties);
    };

    /**
     * Encodes the specified m_properties message. Does not implicitly {@link m_properties.verify|verify} messages.
     * @function encode
     * @memberof m_properties
     * @static
     * @param {Im_properties} message m_properties message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_properties.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.value != null && Object.hasOwnProperty.call(message, "value"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.value);
        return writer;
    };

    /**
     * Encodes the specified m_properties message, length delimited. Does not implicitly {@link m_properties.verify|verify} messages.
     * @function encodeDelimited
     * @memberof m_properties
     * @static
     * @param {Im_properties} message m_properties message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_properties.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a m_properties message from the specified reader or buffer.
     * @function decode
     * @memberof m_properties
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {m_properties} m_properties
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_properties.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.m_properties();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.value = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a m_properties message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof m_properties
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {m_properties} m_properties
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_properties.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a m_properties message.
     * @function verify
     * @memberof m_properties
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    m_properties.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.value != null && message.hasOwnProperty("value"))
            if (!$util.isString(message.value))
                return "value: string expected";
        return null;
    };

    /**
     * Creates a m_properties message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof m_properties
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {m_properties} m_properties
     */
    m_properties.fromObject = function fromObject(object) {
        if (object instanceof $root.m_properties)
            return object;
        let message = new $root.m_properties();
        if (object.name != null)
            message.name = String(object.name);
        if (object.value != null)
            message.value = String(object.value);
        return message;
    };

    /**
     * Creates a plain object from a m_properties message. Also converts values to other types if specified.
     * @function toObject
     * @memberof m_properties
     * @static
     * @param {m_properties} message m_properties
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    m_properties.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.value = "";
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.value != null && message.hasOwnProperty("value"))
            object.value = message.value;
        return object;
    };

    /**
     * Converts this m_properties to JSON.
     * @function toJSON
     * @memberof m_properties
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    m_properties.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for m_properties
     * @function getTypeUrl
     * @memberof m_properties
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    m_properties.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/m_properties";
    };

    return m_properties;
})();

export const m_point_list = $root.m_point_list = (() => {

    /**
     * Properties of a m_point_list.
     * @exports Im_point_list
     * @interface Im_point_list
     * @property {Array.<Im_point>|null} [points] m_point_list points
     */

    /**
     * Constructs a new m_point_list.
     * @exports m_point_list
     * @classdesc Represents a m_point_list.
     * @implements Im_point_list
     * @constructor
     * @param {Im_point_list=} [properties] Properties to set
     */
    function m_point_list(properties) {
        this.points = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * m_point_list points.
     * @member {Array.<Im_point>} points
     * @memberof m_point_list
     * @instance
     */
    m_point_list.prototype.points = $util.emptyArray;

    /**
     * Creates a new m_point_list instance using the specified properties.
     * @function create
     * @memberof m_point_list
     * @static
     * @param {Im_point_list=} [properties] Properties to set
     * @returns {m_point_list} m_point_list instance
     */
    m_point_list.create = function create(properties) {
        return new m_point_list(properties);
    };

    /**
     * Encodes the specified m_point_list message. Does not implicitly {@link m_point_list.verify|verify} messages.
     * @function encode
     * @memberof m_point_list
     * @static
     * @param {Im_point_list} message m_point_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_point_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.points != null && message.points.length)
            for (let i = 0; i < message.points.length; ++i)
                $root.m_point.encode(message.points[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified m_point_list message, length delimited. Does not implicitly {@link m_point_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof m_point_list
     * @static
     * @param {Im_point_list} message m_point_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_point_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a m_point_list message from the specified reader or buffer.
     * @function decode
     * @memberof m_point_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {m_point_list} m_point_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_point_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.m_point_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.points && message.points.length))
                        message.points = [];
                    message.points.push($root.m_point.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a m_point_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof m_point_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {m_point_list} m_point_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_point_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a m_point_list message.
     * @function verify
     * @memberof m_point_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    m_point_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.points != null && message.hasOwnProperty("points")) {
            if (!Array.isArray(message.points))
                return "points: array expected";
            for (let i = 0; i < message.points.length; ++i) {
                let error = $root.m_point.verify(message.points[i]);
                if (error)
                    return "points." + error;
            }
        }
        return null;
    };

    /**
     * Creates a m_point_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof m_point_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {m_point_list} m_point_list
     */
    m_point_list.fromObject = function fromObject(object) {
        if (object instanceof $root.m_point_list)
            return object;
        let message = new $root.m_point_list();
        if (object.points) {
            if (!Array.isArray(object.points))
                throw TypeError(".m_point_list.points: array expected");
            message.points = [];
            for (let i = 0; i < object.points.length; ++i) {
                if (typeof object.points[i] !== "object")
                    throw TypeError(".m_point_list.points: object expected");
                message.points[i] = $root.m_point.fromObject(object.points[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a m_point_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof m_point_list
     * @static
     * @param {m_point_list} message m_point_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    m_point_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.points = [];
        if (message.points && message.points.length) {
            object.points = [];
            for (let j = 0; j < message.points.length; ++j)
                object.points[j] = $root.m_point.toObject(message.points[j], options);
        }
        return object;
    };

    /**
     * Converts this m_point_list to JSON.
     * @function toJSON
     * @memberof m_point_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    m_point_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for m_point_list
     * @function getTypeUrl
     * @memberof m_point_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    m_point_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/m_point_list";
    };

    return m_point_list;
})();

export const m_point = $root.m_point = (() => {

    /**
     * Properties of a m_point.
     * @exports Im_point
     * @interface Im_point
     * @property {string|null} [name] m_point name
     * @property {string|null} [path] m_point path
     * @property {string|null} [value] m_point value
     * @property {Array.<Im_properties>|null} [properties] m_point properties
     */

    /**
     * Constructs a new m_point.
     * @exports m_point
     * @classdesc Represents a m_point.
     * @implements Im_point
     * @constructor
     * @param {Im_point=} [properties] Properties to set
     */
    function m_point(properties) {
        this.properties = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * m_point name.
     * @member {string} name
     * @memberof m_point
     * @instance
     */
    m_point.prototype.name = "";

    /**
     * m_point path.
     * @member {string} path
     * @memberof m_point
     * @instance
     */
    m_point.prototype.path = "";

    /**
     * m_point value.
     * @member {string} value
     * @memberof m_point
     * @instance
     */
    m_point.prototype.value = "";

    /**
     * m_point properties.
     * @member {Array.<Im_properties>} properties
     * @memberof m_point
     * @instance
     */
    m_point.prototype.properties = $util.emptyArray;

    /**
     * Creates a new m_point instance using the specified properties.
     * @function create
     * @memberof m_point
     * @static
     * @param {Im_point=} [properties] Properties to set
     * @returns {m_point} m_point instance
     */
    m_point.create = function create(properties) {
        return new m_point(properties);
    };

    /**
     * Encodes the specified m_point message. Does not implicitly {@link m_point.verify|verify} messages.
     * @function encode
     * @memberof m_point
     * @static
     * @param {Im_point} message m_point message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_point.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.path != null && Object.hasOwnProperty.call(message, "path"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.path);
        if (message.value != null && Object.hasOwnProperty.call(message, "value"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.value);
        if (message.properties != null && message.properties.length)
            for (let i = 0; i < message.properties.length; ++i)
                $root.m_properties.encode(message.properties[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified m_point message, length delimited. Does not implicitly {@link m_point.verify|verify} messages.
     * @function encodeDelimited
     * @memberof m_point
     * @static
     * @param {Im_point} message m_point message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_point.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a m_point message from the specified reader or buffer.
     * @function decode
     * @memberof m_point
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {m_point} m_point
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_point.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.m_point();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.path = reader.string();
                    break;
                }
            case 3: {
                    message.value = reader.string();
                    break;
                }
            case 4: {
                    if (!(message.properties && message.properties.length))
                        message.properties = [];
                    message.properties.push($root.m_properties.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a m_point message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof m_point
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {m_point} m_point
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_point.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a m_point message.
     * @function verify
     * @memberof m_point
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    m_point.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.path != null && message.hasOwnProperty("path"))
            if (!$util.isString(message.path))
                return "path: string expected";
        if (message.value != null && message.hasOwnProperty("value"))
            if (!$util.isString(message.value))
                return "value: string expected";
        if (message.properties != null && message.hasOwnProperty("properties")) {
            if (!Array.isArray(message.properties))
                return "properties: array expected";
            for (let i = 0; i < message.properties.length; ++i) {
                let error = $root.m_properties.verify(message.properties[i]);
                if (error)
                    return "properties." + error;
            }
        }
        return null;
    };

    /**
     * Creates a m_point message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof m_point
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {m_point} m_point
     */
    m_point.fromObject = function fromObject(object) {
        if (object instanceof $root.m_point)
            return object;
        let message = new $root.m_point();
        if (object.name != null)
            message.name = String(object.name);
        if (object.path != null)
            message.path = String(object.path);
        if (object.value != null)
            message.value = String(object.value);
        if (object.properties) {
            if (!Array.isArray(object.properties))
                throw TypeError(".m_point.properties: array expected");
            message.properties = [];
            for (let i = 0; i < object.properties.length; ++i) {
                if (typeof object.properties[i] !== "object")
                    throw TypeError(".m_point.properties: object expected");
                message.properties[i] = $root.m_properties.fromObject(object.properties[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a m_point message. Also converts values to other types if specified.
     * @function toObject
     * @memberof m_point
     * @static
     * @param {m_point} message m_point
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    m_point.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.properties = [];
        if (options.defaults) {
            object.name = "";
            object.path = "";
            object.value = "";
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.path != null && message.hasOwnProperty("path"))
            object.path = message.path;
        if (message.value != null && message.hasOwnProperty("value"))
            object.value = message.value;
        if (message.properties && message.properties.length) {
            object.properties = [];
            for (let j = 0; j < message.properties.length; ++j)
                object.properties[j] = $root.m_properties.toObject(message.properties[j], options);
        }
        return object;
    };

    /**
     * Converts this m_point to JSON.
     * @function toJSON
     * @memberof m_point
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    m_point.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for m_point
     * @function getTypeUrl
     * @memberof m_point
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    m_point.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/m_point";
    };

    return m_point;
})();

export const m_device_list = $root.m_device_list = (() => {

    /**
     * Properties of a m_device_list.
     * @exports Im_device_list
     * @interface Im_device_list
     * @property {Array.<Im_device>|null} [devices] m_device_list devices
     */

    /**
     * Constructs a new m_device_list.
     * @exports m_device_list
     * @classdesc Represents a m_device_list.
     * @implements Im_device_list
     * @constructor
     * @param {Im_device_list=} [properties] Properties to set
     */
    function m_device_list(properties) {
        this.devices = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * m_device_list devices.
     * @member {Array.<Im_device>} devices
     * @memberof m_device_list
     * @instance
     */
    m_device_list.prototype.devices = $util.emptyArray;

    /**
     * Creates a new m_device_list instance using the specified properties.
     * @function create
     * @memberof m_device_list
     * @static
     * @param {Im_device_list=} [properties] Properties to set
     * @returns {m_device_list} m_device_list instance
     */
    m_device_list.create = function create(properties) {
        return new m_device_list(properties);
    };

    /**
     * Encodes the specified m_device_list message. Does not implicitly {@link m_device_list.verify|verify} messages.
     * @function encode
     * @memberof m_device_list
     * @static
     * @param {Im_device_list} message m_device_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_device_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.devices != null && message.devices.length)
            for (let i = 0; i < message.devices.length; ++i)
                $root.m_device.encode(message.devices[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified m_device_list message, length delimited. Does not implicitly {@link m_device_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof m_device_list
     * @static
     * @param {Im_device_list} message m_device_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_device_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a m_device_list message from the specified reader or buffer.
     * @function decode
     * @memberof m_device_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {m_device_list} m_device_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_device_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.m_device_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.devices && message.devices.length))
                        message.devices = [];
                    message.devices.push($root.m_device.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a m_device_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof m_device_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {m_device_list} m_device_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_device_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a m_device_list message.
     * @function verify
     * @memberof m_device_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    m_device_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.devices != null && message.hasOwnProperty("devices")) {
            if (!Array.isArray(message.devices))
                return "devices: array expected";
            for (let i = 0; i < message.devices.length; ++i) {
                let error = $root.m_device.verify(message.devices[i]);
                if (error)
                    return "devices." + error;
            }
        }
        return null;
    };

    /**
     * Creates a m_device_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof m_device_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {m_device_list} m_device_list
     */
    m_device_list.fromObject = function fromObject(object) {
        if (object instanceof $root.m_device_list)
            return object;
        let message = new $root.m_device_list();
        if (object.devices) {
            if (!Array.isArray(object.devices))
                throw TypeError(".m_device_list.devices: array expected");
            message.devices = [];
            for (let i = 0; i < object.devices.length; ++i) {
                if (typeof object.devices[i] !== "object")
                    throw TypeError(".m_device_list.devices: object expected");
                message.devices[i] = $root.m_device.fromObject(object.devices[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a m_device_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof m_device_list
     * @static
     * @param {m_device_list} message m_device_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    m_device_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.devices = [];
        if (message.devices && message.devices.length) {
            object.devices = [];
            for (let j = 0; j < message.devices.length; ++j)
                object.devices[j] = $root.m_device.toObject(message.devices[j], options);
        }
        return object;
    };

    /**
     * Converts this m_device_list to JSON.
     * @function toJSON
     * @memberof m_device_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    m_device_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for m_device_list
     * @function getTypeUrl
     * @memberof m_device_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    m_device_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/m_device_list";
    };

    return m_device_list;
})();

export const m_device = $root.m_device = (() => {

    /**
     * Properties of a m_device.
     * @exports Im_device
     * @interface Im_device
     * @property {string|null} [name] m_device name
     * @property {string|null} [value] m_device value
     * @property {string|null} [path] m_device path
     * @property {Array.<Im_properties>|null} [properties] m_device properties
     * @property {Array.<Im_point>|null} [points] m_device points
     */

    /**
     * Constructs a new m_device.
     * @exports m_device
     * @classdesc Represents a m_device.
     * @implements Im_device
     * @constructor
     * @param {Im_device=} [properties] Properties to set
     */
    function m_device(properties) {
        this.properties = [];
        this.points = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * m_device name.
     * @member {string} name
     * @memberof m_device
     * @instance
     */
    m_device.prototype.name = "";

    /**
     * m_device value.
     * @member {string} value
     * @memberof m_device
     * @instance
     */
    m_device.prototype.value = "";

    /**
     * m_device path.
     * @member {string} path
     * @memberof m_device
     * @instance
     */
    m_device.prototype.path = "";

    /**
     * m_device properties.
     * @member {Array.<Im_properties>} properties
     * @memberof m_device
     * @instance
     */
    m_device.prototype.properties = $util.emptyArray;

    /**
     * m_device points.
     * @member {Array.<Im_point>} points
     * @memberof m_device
     * @instance
     */
    m_device.prototype.points = $util.emptyArray;

    /**
     * Creates a new m_device instance using the specified properties.
     * @function create
     * @memberof m_device
     * @static
     * @param {Im_device=} [properties] Properties to set
     * @returns {m_device} m_device instance
     */
    m_device.create = function create(properties) {
        return new m_device(properties);
    };

    /**
     * Encodes the specified m_device message. Does not implicitly {@link m_device.verify|verify} messages.
     * @function encode
     * @memberof m_device
     * @static
     * @param {Im_device} message m_device message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_device.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.value != null && Object.hasOwnProperty.call(message, "value"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.value);
        if (message.path != null && Object.hasOwnProperty.call(message, "path"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.path);
        if (message.properties != null && message.properties.length)
            for (let i = 0; i < message.properties.length; ++i)
                $root.m_properties.encode(message.properties[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
        if (message.points != null && message.points.length)
            for (let i = 0; i < message.points.length; ++i)
                $root.m_point.encode(message.points[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified m_device message, length delimited. Does not implicitly {@link m_device.verify|verify} messages.
     * @function encodeDelimited
     * @memberof m_device
     * @static
     * @param {Im_device} message m_device message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    m_device.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a m_device message from the specified reader or buffer.
     * @function decode
     * @memberof m_device
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {m_device} m_device
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_device.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.m_device();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.value = reader.string();
                    break;
                }
            case 3: {
                    message.path = reader.string();
                    break;
                }
            case 4: {
                    if (!(message.properties && message.properties.length))
                        message.properties = [];
                    message.properties.push($root.m_properties.decode(reader, reader.uint32()));
                    break;
                }
            case 5: {
                    if (!(message.points && message.points.length))
                        message.points = [];
                    message.points.push($root.m_point.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a m_device message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof m_device
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {m_device} m_device
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    m_device.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a m_device message.
     * @function verify
     * @memberof m_device
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    m_device.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.value != null && message.hasOwnProperty("value"))
            if (!$util.isString(message.value))
                return "value: string expected";
        if (message.path != null && message.hasOwnProperty("path"))
            if (!$util.isString(message.path))
                return "path: string expected";
        if (message.properties != null && message.hasOwnProperty("properties")) {
            if (!Array.isArray(message.properties))
                return "properties: array expected";
            for (let i = 0; i < message.properties.length; ++i) {
                let error = $root.m_properties.verify(message.properties[i]);
                if (error)
                    return "properties." + error;
            }
        }
        if (message.points != null && message.hasOwnProperty("points")) {
            if (!Array.isArray(message.points))
                return "points: array expected";
            for (let i = 0; i < message.points.length; ++i) {
                let error = $root.m_point.verify(message.points[i]);
                if (error)
                    return "points." + error;
            }
        }
        return null;
    };

    /**
     * Creates a m_device message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof m_device
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {m_device} m_device
     */
    m_device.fromObject = function fromObject(object) {
        if (object instanceof $root.m_device)
            return object;
        let message = new $root.m_device();
        if (object.name != null)
            message.name = String(object.name);
        if (object.value != null)
            message.value = String(object.value);
        if (object.path != null)
            message.path = String(object.path);
        if (object.properties) {
            if (!Array.isArray(object.properties))
                throw TypeError(".m_device.properties: array expected");
            message.properties = [];
            for (let i = 0; i < object.properties.length; ++i) {
                if (typeof object.properties[i] !== "object")
                    throw TypeError(".m_device.properties: object expected");
                message.properties[i] = $root.m_properties.fromObject(object.properties[i]);
            }
        }
        if (object.points) {
            if (!Array.isArray(object.points))
                throw TypeError(".m_device.points: array expected");
            message.points = [];
            for (let i = 0; i < object.points.length; ++i) {
                if (typeof object.points[i] !== "object")
                    throw TypeError(".m_device.points: object expected");
                message.points[i] = $root.m_point.fromObject(object.points[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a m_device message. Also converts values to other types if specified.
     * @function toObject
     * @memberof m_device
     * @static
     * @param {m_device} message m_device
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    m_device.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults) {
            object.properties = [];
            object.points = [];
        }
        if (options.defaults) {
            object.name = "";
            object.value = "";
            object.path = "";
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.value != null && message.hasOwnProperty("value"))
            object.value = message.value;
        if (message.path != null && message.hasOwnProperty("path"))
            object.path = message.path;
        if (message.properties && message.properties.length) {
            object.properties = [];
            for (let j = 0; j < message.properties.length; ++j)
                object.properties[j] = $root.m_properties.toObject(message.properties[j], options);
        }
        if (message.points && message.points.length) {
            object.points = [];
            for (let j = 0; j < message.points.length; ++j)
                object.points[j] = $root.m_point.toObject(message.points[j], options);
        }
        return object;
    };

    /**
     * Converts this m_device to JSON.
     * @function toJSON
     * @memberof m_device
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    m_device.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for m_device
     * @function getTypeUrl
     * @memberof m_device
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    m_device.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/m_device";
    };

    return m_device;
})();

export const info = $root.info = (() => {

    /**
     * Properties of an info.
     * @exports Iinfo
     * @interface Iinfo
     * @property {IBasicinfo|null} [basicinfo] info basicinfo
     * @property {IHostinfo|null} [hostinfo] info hostinfo
     * @property {IMeminfo|null} [meminfo] info meminfo
     * @property {Array.<IDiskinfo>|null} [diskinfo] info diskinfo
     * @property {Array.<INetinfo>|null} [netinfo] info netinfo
     */

    /**
     * Constructs a new info.
     * @exports info
     * @classdesc Represents an info.
     * @implements Iinfo
     * @constructor
     * @param {Iinfo=} [properties] Properties to set
     */
    function info(properties) {
        this.diskinfo = [];
        this.netinfo = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * info basicinfo.
     * @member {IBasicinfo|null|undefined} basicinfo
     * @memberof info
     * @instance
     */
    info.prototype.basicinfo = null;

    /**
     * info hostinfo.
     * @member {IHostinfo|null|undefined} hostinfo
     * @memberof info
     * @instance
     */
    info.prototype.hostinfo = null;

    /**
     * info meminfo.
     * @member {IMeminfo|null|undefined} meminfo
     * @memberof info
     * @instance
     */
    info.prototype.meminfo = null;

    /**
     * info diskinfo.
     * @member {Array.<IDiskinfo>} diskinfo
     * @memberof info
     * @instance
     */
    info.prototype.diskinfo = $util.emptyArray;

    /**
     * info netinfo.
     * @member {Array.<INetinfo>} netinfo
     * @memberof info
     * @instance
     */
    info.prototype.netinfo = $util.emptyArray;

    /**
     * Creates a new info instance using the specified properties.
     * @function create
     * @memberof info
     * @static
     * @param {Iinfo=} [properties] Properties to set
     * @returns {info} info instance
     */
    info.create = function create(properties) {
        return new info(properties);
    };

    /**
     * Encodes the specified info message. Does not implicitly {@link info.verify|verify} messages.
     * @function encode
     * @memberof info
     * @static
     * @param {Iinfo} message info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.basicinfo != null && Object.hasOwnProperty.call(message, "basicinfo"))
            $root.Basicinfo.encode(message.basicinfo, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        if (message.hostinfo != null && Object.hasOwnProperty.call(message, "hostinfo"))
            $root.Hostinfo.encode(message.hostinfo, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
        if (message.meminfo != null && Object.hasOwnProperty.call(message, "meminfo"))
            $root.Meminfo.encode(message.meminfo, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
        if (message.diskinfo != null && message.diskinfo.length)
            for (let i = 0; i < message.diskinfo.length; ++i)
                $root.Diskinfo.encode(message.diskinfo[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
        if (message.netinfo != null && message.netinfo.length)
            for (let i = 0; i < message.netinfo.length; ++i)
                $root.Netinfo.encode(message.netinfo[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified info message, length delimited. Does not implicitly {@link info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof info
     * @static
     * @param {Iinfo} message info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes an info message from the specified reader or buffer.
     * @function decode
     * @memberof info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {info} info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.basicinfo = $root.Basicinfo.decode(reader, reader.uint32());
                    break;
                }
            case 2: {
                    message.hostinfo = $root.Hostinfo.decode(reader, reader.uint32());
                    break;
                }
            case 3: {
                    message.meminfo = $root.Meminfo.decode(reader, reader.uint32());
                    break;
                }
            case 4: {
                    if (!(message.diskinfo && message.diskinfo.length))
                        message.diskinfo = [];
                    message.diskinfo.push($root.Diskinfo.decode(reader, reader.uint32()));
                    break;
                }
            case 5: {
                    if (!(message.netinfo && message.netinfo.length))
                        message.netinfo = [];
                    message.netinfo.push($root.Netinfo.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes an info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {info} info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies an info message.
     * @function verify
     * @memberof info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.basicinfo != null && message.hasOwnProperty("basicinfo")) {
            let error = $root.Basicinfo.verify(message.basicinfo);
            if (error)
                return "basicinfo." + error;
        }
        if (message.hostinfo != null && message.hasOwnProperty("hostinfo")) {
            let error = $root.Hostinfo.verify(message.hostinfo);
            if (error)
                return "hostinfo." + error;
        }
        if (message.meminfo != null && message.hasOwnProperty("meminfo")) {
            let error = $root.Meminfo.verify(message.meminfo);
            if (error)
                return "meminfo." + error;
        }
        if (message.diskinfo != null && message.hasOwnProperty("diskinfo")) {
            if (!Array.isArray(message.diskinfo))
                return "diskinfo: array expected";
            for (let i = 0; i < message.diskinfo.length; ++i) {
                let error = $root.Diskinfo.verify(message.diskinfo[i]);
                if (error)
                    return "diskinfo." + error;
            }
        }
        if (message.netinfo != null && message.hasOwnProperty("netinfo")) {
            if (!Array.isArray(message.netinfo))
                return "netinfo: array expected";
            for (let i = 0; i < message.netinfo.length; ++i) {
                let error = $root.Netinfo.verify(message.netinfo[i]);
                if (error)
                    return "netinfo." + error;
            }
        }
        return null;
    };

    /**
     * Creates an info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {info} info
     */
    info.fromObject = function fromObject(object) {
        if (object instanceof $root.info)
            return object;
        let message = new $root.info();
        if (object.basicinfo != null) {
            if (typeof object.basicinfo !== "object")
                throw TypeError(".info.basicinfo: object expected");
            message.basicinfo = $root.Basicinfo.fromObject(object.basicinfo);
        }
        if (object.hostinfo != null) {
            if (typeof object.hostinfo !== "object")
                throw TypeError(".info.hostinfo: object expected");
            message.hostinfo = $root.Hostinfo.fromObject(object.hostinfo);
        }
        if (object.meminfo != null) {
            if (typeof object.meminfo !== "object")
                throw TypeError(".info.meminfo: object expected");
            message.meminfo = $root.Meminfo.fromObject(object.meminfo);
        }
        if (object.diskinfo) {
            if (!Array.isArray(object.diskinfo))
                throw TypeError(".info.diskinfo: array expected");
            message.diskinfo = [];
            for (let i = 0; i < object.diskinfo.length; ++i) {
                if (typeof object.diskinfo[i] !== "object")
                    throw TypeError(".info.diskinfo: object expected");
                message.diskinfo[i] = $root.Diskinfo.fromObject(object.diskinfo[i]);
            }
        }
        if (object.netinfo) {
            if (!Array.isArray(object.netinfo))
                throw TypeError(".info.netinfo: array expected");
            message.netinfo = [];
            for (let i = 0; i < object.netinfo.length; ++i) {
                if (typeof object.netinfo[i] !== "object")
                    throw TypeError(".info.netinfo: object expected");
                message.netinfo[i] = $root.Netinfo.fromObject(object.netinfo[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from an info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof info
     * @static
     * @param {info} message info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults) {
            object.diskinfo = [];
            object.netinfo = [];
        }
        if (options.defaults) {
            object.basicinfo = null;
            object.hostinfo = null;
            object.meminfo = null;
        }
        if (message.basicinfo != null && message.hasOwnProperty("basicinfo"))
            object.basicinfo = $root.Basicinfo.toObject(message.basicinfo, options);
        if (message.hostinfo != null && message.hasOwnProperty("hostinfo"))
            object.hostinfo = $root.Hostinfo.toObject(message.hostinfo, options);
        if (message.meminfo != null && message.hasOwnProperty("meminfo"))
            object.meminfo = $root.Meminfo.toObject(message.meminfo, options);
        if (message.diskinfo && message.diskinfo.length) {
            object.diskinfo = [];
            for (let j = 0; j < message.diskinfo.length; ++j)
                object.diskinfo[j] = $root.Diskinfo.toObject(message.diskinfo[j], options);
        }
        if (message.netinfo && message.netinfo.length) {
            object.netinfo = [];
            for (let j = 0; j < message.netinfo.length; ++j)
                object.netinfo[j] = $root.Netinfo.toObject(message.netinfo[j], options);
        }
        return object;
    };

    /**
     * Converts this info to JSON.
     * @function toJSON
     * @memberof info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for info
     * @function getTypeUrl
     * @memberof info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/info";
    };

    return info;
})();

export const Basicinfo = $root.Basicinfo = (() => {

    /**
     * Properties of a Basicinfo.
     * @exports IBasicinfo
     * @interface IBasicinfo
     * @property {string|null} [model] Basicinfo model
     * @property {string|null} [sn] Basicinfo sn
     * @property {string|null} [firstTime] Basicinfo firstTime
     */

    /**
     * Constructs a new Basicinfo.
     * @exports Basicinfo
     * @classdesc Represents a Basicinfo.
     * @implements IBasicinfo
     * @constructor
     * @param {IBasicinfo=} [properties] Properties to set
     */
    function Basicinfo(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * Basicinfo model.
     * @member {string} model
     * @memberof Basicinfo
     * @instance
     */
    Basicinfo.prototype.model = "";

    /**
     * Basicinfo sn.
     * @member {string} sn
     * @memberof Basicinfo
     * @instance
     */
    Basicinfo.prototype.sn = "";

    /**
     * Basicinfo firstTime.
     * @member {string} firstTime
     * @memberof Basicinfo
     * @instance
     */
    Basicinfo.prototype.firstTime = "";

    /**
     * Creates a new Basicinfo instance using the specified properties.
     * @function create
     * @memberof Basicinfo
     * @static
     * @param {IBasicinfo=} [properties] Properties to set
     * @returns {Basicinfo} Basicinfo instance
     */
    Basicinfo.create = function create(properties) {
        return new Basicinfo(properties);
    };

    /**
     * Encodes the specified Basicinfo message. Does not implicitly {@link Basicinfo.verify|verify} messages.
     * @function encode
     * @memberof Basicinfo
     * @static
     * @param {IBasicinfo} message Basicinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Basicinfo.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.model != null && Object.hasOwnProperty.call(message, "model"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.model);
        if (message.sn != null && Object.hasOwnProperty.call(message, "sn"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.sn);
        if (message.firstTime != null && Object.hasOwnProperty.call(message, "firstTime"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.firstTime);
        return writer;
    };

    /**
     * Encodes the specified Basicinfo message, length delimited. Does not implicitly {@link Basicinfo.verify|verify} messages.
     * @function encodeDelimited
     * @memberof Basicinfo
     * @static
     * @param {IBasicinfo} message Basicinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Basicinfo.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a Basicinfo message from the specified reader or buffer.
     * @function decode
     * @memberof Basicinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {Basicinfo} Basicinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Basicinfo.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Basicinfo();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.model = reader.string();
                    break;
                }
            case 2: {
                    message.sn = reader.string();
                    break;
                }
            case 3: {
                    message.firstTime = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a Basicinfo message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof Basicinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {Basicinfo} Basicinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Basicinfo.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a Basicinfo message.
     * @function verify
     * @memberof Basicinfo
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    Basicinfo.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.model != null && message.hasOwnProperty("model"))
            if (!$util.isString(message.model))
                return "model: string expected";
        if (message.sn != null && message.hasOwnProperty("sn"))
            if (!$util.isString(message.sn))
                return "sn: string expected";
        if (message.firstTime != null && message.hasOwnProperty("firstTime"))
            if (!$util.isString(message.firstTime))
                return "firstTime: string expected";
        return null;
    };

    /**
     * Creates a Basicinfo message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof Basicinfo
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {Basicinfo} Basicinfo
     */
    Basicinfo.fromObject = function fromObject(object) {
        if (object instanceof $root.Basicinfo)
            return object;
        let message = new $root.Basicinfo();
        if (object.model != null)
            message.model = String(object.model);
        if (object.sn != null)
            message.sn = String(object.sn);
        if (object.firstTime != null)
            message.firstTime = String(object.firstTime);
        return message;
    };

    /**
     * Creates a plain object from a Basicinfo message. Also converts values to other types if specified.
     * @function toObject
     * @memberof Basicinfo
     * @static
     * @param {Basicinfo} message Basicinfo
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    Basicinfo.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.model = "";
            object.sn = "";
            object.firstTime = "";
        }
        if (message.model != null && message.hasOwnProperty("model"))
            object.model = message.model;
        if (message.sn != null && message.hasOwnProperty("sn"))
            object.sn = message.sn;
        if (message.firstTime != null && message.hasOwnProperty("firstTime"))
            object.firstTime = message.firstTime;
        return object;
    };

    /**
     * Converts this Basicinfo to JSON.
     * @function toJSON
     * @memberof Basicinfo
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    Basicinfo.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for Basicinfo
     * @function getTypeUrl
     * @memberof Basicinfo
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    Basicinfo.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/Basicinfo";
    };

    return Basicinfo;
})();

export const Hostinfo = $root.Hostinfo = (() => {

    /**
     * Properties of a Hostinfo.
     * @exports IHostinfo
     * @interface IHostinfo
     * @property {number|null} [cpu] Hostinfo cpu
     * @property {string|null} [uptime] Hostinfo uptime
     * @property {string|null} [boottime] Hostinfo boottime
     */

    /**
     * Constructs a new Hostinfo.
     * @exports Hostinfo
     * @classdesc Represents a Hostinfo.
     * @implements IHostinfo
     * @constructor
     * @param {IHostinfo=} [properties] Properties to set
     */
    function Hostinfo(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * Hostinfo cpu.
     * @member {number} cpu
     * @memberof Hostinfo
     * @instance
     */
    Hostinfo.prototype.cpu = 0;

    /**
     * Hostinfo uptime.
     * @member {string} uptime
     * @memberof Hostinfo
     * @instance
     */
    Hostinfo.prototype.uptime = "";

    /**
     * Hostinfo boottime.
     * @member {string} boottime
     * @memberof Hostinfo
     * @instance
     */
    Hostinfo.prototype.boottime = "";

    /**
     * Creates a new Hostinfo instance using the specified properties.
     * @function create
     * @memberof Hostinfo
     * @static
     * @param {IHostinfo=} [properties] Properties to set
     * @returns {Hostinfo} Hostinfo instance
     */
    Hostinfo.create = function create(properties) {
        return new Hostinfo(properties);
    };

    /**
     * Encodes the specified Hostinfo message. Does not implicitly {@link Hostinfo.verify|verify} messages.
     * @function encode
     * @memberof Hostinfo
     * @static
     * @param {IHostinfo} message Hostinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Hostinfo.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.cpu != null && Object.hasOwnProperty.call(message, "cpu"))
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cpu);
        if (message.uptime != null && Object.hasOwnProperty.call(message, "uptime"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.uptime);
        if (message.boottime != null && Object.hasOwnProperty.call(message, "boottime"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.boottime);
        return writer;
    };

    /**
     * Encodes the specified Hostinfo message, length delimited. Does not implicitly {@link Hostinfo.verify|verify} messages.
     * @function encodeDelimited
     * @memberof Hostinfo
     * @static
     * @param {IHostinfo} message Hostinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Hostinfo.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a Hostinfo message from the specified reader or buffer.
     * @function decode
     * @memberof Hostinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {Hostinfo} Hostinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Hostinfo.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Hostinfo();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.cpu = reader.int32();
                    break;
                }
            case 2: {
                    message.uptime = reader.string();
                    break;
                }
            case 3: {
                    message.boottime = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a Hostinfo message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof Hostinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {Hostinfo} Hostinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Hostinfo.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a Hostinfo message.
     * @function verify
     * @memberof Hostinfo
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    Hostinfo.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.cpu != null && message.hasOwnProperty("cpu"))
            if (!$util.isInteger(message.cpu))
                return "cpu: integer expected";
        if (message.uptime != null && message.hasOwnProperty("uptime"))
            if (!$util.isString(message.uptime))
                return "uptime: string expected";
        if (message.boottime != null && message.hasOwnProperty("boottime"))
            if (!$util.isString(message.boottime))
                return "boottime: string expected";
        return null;
    };

    /**
     * Creates a Hostinfo message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof Hostinfo
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {Hostinfo} Hostinfo
     */
    Hostinfo.fromObject = function fromObject(object) {
        if (object instanceof $root.Hostinfo)
            return object;
        let message = new $root.Hostinfo();
        if (object.cpu != null)
            message.cpu = object.cpu | 0;
        if (object.uptime != null)
            message.uptime = String(object.uptime);
        if (object.boottime != null)
            message.boottime = String(object.boottime);
        return message;
    };

    /**
     * Creates a plain object from a Hostinfo message. Also converts values to other types if specified.
     * @function toObject
     * @memberof Hostinfo
     * @static
     * @param {Hostinfo} message Hostinfo
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    Hostinfo.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.cpu = 0;
            object.uptime = "";
            object.boottime = "";
        }
        if (message.cpu != null && message.hasOwnProperty("cpu"))
            object.cpu = message.cpu;
        if (message.uptime != null && message.hasOwnProperty("uptime"))
            object.uptime = message.uptime;
        if (message.boottime != null && message.hasOwnProperty("boottime"))
            object.boottime = message.boottime;
        return object;
    };

    /**
     * Converts this Hostinfo to JSON.
     * @function toJSON
     * @memberof Hostinfo
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    Hostinfo.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for Hostinfo
     * @function getTypeUrl
     * @memberof Hostinfo
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    Hostinfo.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/Hostinfo";
    };

    return Hostinfo;
})();

export const Meminfo = $root.Meminfo = (() => {

    /**
     * Properties of a Meminfo.
     * @exports IMeminfo
     * @interface IMeminfo
     * @property {number|null} [total] Meminfo total
     * @property {number|null} [available] Meminfo available
     * @property {number|null} [used] Meminfo used
     * @property {number|null} [usedPercent] Meminfo usedPercent
     * @property {number|null} [free] Meminfo free
     * @property {number|null} [buffers] Meminfo buffers
     * @property {number|null} [cached] Meminfo cached
     */

    /**
     * Constructs a new Meminfo.
     * @exports Meminfo
     * @classdesc Represents a Meminfo.
     * @implements IMeminfo
     * @constructor
     * @param {IMeminfo=} [properties] Properties to set
     */
    function Meminfo(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * Meminfo total.
     * @member {number} total
     * @memberof Meminfo
     * @instance
     */
    Meminfo.prototype.total = 0;

    /**
     * Meminfo available.
     * @member {number} available
     * @memberof Meminfo
     * @instance
     */
    Meminfo.prototype.available = 0;

    /**
     * Meminfo used.
     * @member {number} used
     * @memberof Meminfo
     * @instance
     */
    Meminfo.prototype.used = 0;

    /**
     * Meminfo usedPercent.
     * @member {number} usedPercent
     * @memberof Meminfo
     * @instance
     */
    Meminfo.prototype.usedPercent = 0;

    /**
     * Meminfo free.
     * @member {number} free
     * @memberof Meminfo
     * @instance
     */
    Meminfo.prototype.free = 0;

    /**
     * Meminfo buffers.
     * @member {number} buffers
     * @memberof Meminfo
     * @instance
     */
    Meminfo.prototype.buffers = 0;

    /**
     * Meminfo cached.
     * @member {number} cached
     * @memberof Meminfo
     * @instance
     */
    Meminfo.prototype.cached = 0;

    /**
     * Creates a new Meminfo instance using the specified properties.
     * @function create
     * @memberof Meminfo
     * @static
     * @param {IMeminfo=} [properties] Properties to set
     * @returns {Meminfo} Meminfo instance
     */
    Meminfo.create = function create(properties) {
        return new Meminfo(properties);
    };

    /**
     * Encodes the specified Meminfo message. Does not implicitly {@link Meminfo.verify|verify} messages.
     * @function encode
     * @memberof Meminfo
     * @static
     * @param {IMeminfo} message Meminfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Meminfo.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.total != null && Object.hasOwnProperty.call(message, "total"))
            writer.uint32(/* id 1, wireType 1 =*/9).double(message.total);
        if (message.available != null && Object.hasOwnProperty.call(message, "available"))
            writer.uint32(/* id 2, wireType 1 =*/17).double(message.available);
        if (message.used != null && Object.hasOwnProperty.call(message, "used"))
            writer.uint32(/* id 3, wireType 1 =*/25).double(message.used);
        if (message.usedPercent != null && Object.hasOwnProperty.call(message, "usedPercent"))
            writer.uint32(/* id 4, wireType 1 =*/33).double(message.usedPercent);
        if (message.free != null && Object.hasOwnProperty.call(message, "free"))
            writer.uint32(/* id 5, wireType 1 =*/41).double(message.free);
        if (message.buffers != null && Object.hasOwnProperty.call(message, "buffers"))
            writer.uint32(/* id 6, wireType 1 =*/49).double(message.buffers);
        if (message.cached != null && Object.hasOwnProperty.call(message, "cached"))
            writer.uint32(/* id 7, wireType 1 =*/57).double(message.cached);
        return writer;
    };

    /**
     * Encodes the specified Meminfo message, length delimited. Does not implicitly {@link Meminfo.verify|verify} messages.
     * @function encodeDelimited
     * @memberof Meminfo
     * @static
     * @param {IMeminfo} message Meminfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Meminfo.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a Meminfo message from the specified reader or buffer.
     * @function decode
     * @memberof Meminfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {Meminfo} Meminfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Meminfo.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Meminfo();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.total = reader.double();
                    break;
                }
            case 2: {
                    message.available = reader.double();
                    break;
                }
            case 3: {
                    message.used = reader.double();
                    break;
                }
            case 4: {
                    message.usedPercent = reader.double();
                    break;
                }
            case 5: {
                    message.free = reader.double();
                    break;
                }
            case 6: {
                    message.buffers = reader.double();
                    break;
                }
            case 7: {
                    message.cached = reader.double();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a Meminfo message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof Meminfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {Meminfo} Meminfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Meminfo.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a Meminfo message.
     * @function verify
     * @memberof Meminfo
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    Meminfo.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.total != null && message.hasOwnProperty("total"))
            if (typeof message.total !== "number")
                return "total: number expected";
        if (message.available != null && message.hasOwnProperty("available"))
            if (typeof message.available !== "number")
                return "available: number expected";
        if (message.used != null && message.hasOwnProperty("used"))
            if (typeof message.used !== "number")
                return "used: number expected";
        if (message.usedPercent != null && message.hasOwnProperty("usedPercent"))
            if (typeof message.usedPercent !== "number")
                return "usedPercent: number expected";
        if (message.free != null && message.hasOwnProperty("free"))
            if (typeof message.free !== "number")
                return "free: number expected";
        if (message.buffers != null && message.hasOwnProperty("buffers"))
            if (typeof message.buffers !== "number")
                return "buffers: number expected";
        if (message.cached != null && message.hasOwnProperty("cached"))
            if (typeof message.cached !== "number")
                return "cached: number expected";
        return null;
    };

    /**
     * Creates a Meminfo message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof Meminfo
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {Meminfo} Meminfo
     */
    Meminfo.fromObject = function fromObject(object) {
        if (object instanceof $root.Meminfo)
            return object;
        let message = new $root.Meminfo();
        if (object.total != null)
            message.total = Number(object.total);
        if (object.available != null)
            message.available = Number(object.available);
        if (object.used != null)
            message.used = Number(object.used);
        if (object.usedPercent != null)
            message.usedPercent = Number(object.usedPercent);
        if (object.free != null)
            message.free = Number(object.free);
        if (object.buffers != null)
            message.buffers = Number(object.buffers);
        if (object.cached != null)
            message.cached = Number(object.cached);
        return message;
    };

    /**
     * Creates a plain object from a Meminfo message. Also converts values to other types if specified.
     * @function toObject
     * @memberof Meminfo
     * @static
     * @param {Meminfo} message Meminfo
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    Meminfo.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.total = 0;
            object.available = 0;
            object.used = 0;
            object.usedPercent = 0;
            object.free = 0;
            object.buffers = 0;
            object.cached = 0;
        }
        if (message.total != null && message.hasOwnProperty("total"))
            object.total = options.json && !isFinite(message.total) ? String(message.total) : message.total;
        if (message.available != null && message.hasOwnProperty("available"))
            object.available = options.json && !isFinite(message.available) ? String(message.available) : message.available;
        if (message.used != null && message.hasOwnProperty("used"))
            object.used = options.json && !isFinite(message.used) ? String(message.used) : message.used;
        if (message.usedPercent != null && message.hasOwnProperty("usedPercent"))
            object.usedPercent = options.json && !isFinite(message.usedPercent) ? String(message.usedPercent) : message.usedPercent;
        if (message.free != null && message.hasOwnProperty("free"))
            object.free = options.json && !isFinite(message.free) ? String(message.free) : message.free;
        if (message.buffers != null && message.hasOwnProperty("buffers"))
            object.buffers = options.json && !isFinite(message.buffers) ? String(message.buffers) : message.buffers;
        if (message.cached != null && message.hasOwnProperty("cached"))
            object.cached = options.json && !isFinite(message.cached) ? String(message.cached) : message.cached;
        return object;
    };

    /**
     * Converts this Meminfo to JSON.
     * @function toJSON
     * @memberof Meminfo
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    Meminfo.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for Meminfo
     * @function getTypeUrl
     * @memberof Meminfo
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    Meminfo.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/Meminfo";
    };

    return Meminfo;
})();

export const Diskinfo = $root.Diskinfo = (() => {

    /**
     * Properties of a Diskinfo.
     * @exports IDiskinfo
     * @interface IDiskinfo
     * @property {string|null} [name] Diskinfo name
     * @property {string|null} [path] Diskinfo path
     * @property {number|null} [total] Diskinfo total
     * @property {number|null} [free] Diskinfo free
     * @property {number|null} [used] Diskinfo used
     * @property {number|null} [usedPercent] Diskinfo usedPercent
     */

    /**
     * Constructs a new Diskinfo.
     * @exports Diskinfo
     * @classdesc Represents a Diskinfo.
     * @implements IDiskinfo
     * @constructor
     * @param {IDiskinfo=} [properties] Properties to set
     */
    function Diskinfo(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * Diskinfo name.
     * @member {string} name
     * @memberof Diskinfo
     * @instance
     */
    Diskinfo.prototype.name = "";

    /**
     * Diskinfo path.
     * @member {string} path
     * @memberof Diskinfo
     * @instance
     */
    Diskinfo.prototype.path = "";

    /**
     * Diskinfo total.
     * @member {number} total
     * @memberof Diskinfo
     * @instance
     */
    Diskinfo.prototype.total = 0;

    /**
     * Diskinfo free.
     * @member {number} free
     * @memberof Diskinfo
     * @instance
     */
    Diskinfo.prototype.free = 0;

    /**
     * Diskinfo used.
     * @member {number} used
     * @memberof Diskinfo
     * @instance
     */
    Diskinfo.prototype.used = 0;

    /**
     * Diskinfo usedPercent.
     * @member {number} usedPercent
     * @memberof Diskinfo
     * @instance
     */
    Diskinfo.prototype.usedPercent = 0;

    /**
     * Creates a new Diskinfo instance using the specified properties.
     * @function create
     * @memberof Diskinfo
     * @static
     * @param {IDiskinfo=} [properties] Properties to set
     * @returns {Diskinfo} Diskinfo instance
     */
    Diskinfo.create = function create(properties) {
        return new Diskinfo(properties);
    };

    /**
     * Encodes the specified Diskinfo message. Does not implicitly {@link Diskinfo.verify|verify} messages.
     * @function encode
     * @memberof Diskinfo
     * @static
     * @param {IDiskinfo} message Diskinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Diskinfo.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.path != null && Object.hasOwnProperty.call(message, "path"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.path);
        if (message.total != null && Object.hasOwnProperty.call(message, "total"))
            writer.uint32(/* id 3, wireType 1 =*/25).double(message.total);
        if (message.free != null && Object.hasOwnProperty.call(message, "free"))
            writer.uint32(/* id 4, wireType 1 =*/33).double(message.free);
        if (message.used != null && Object.hasOwnProperty.call(message, "used"))
            writer.uint32(/* id 5, wireType 1 =*/41).double(message.used);
        if (message.usedPercent != null && Object.hasOwnProperty.call(message, "usedPercent"))
            writer.uint32(/* id 6, wireType 1 =*/49).double(message.usedPercent);
        return writer;
    };

    /**
     * Encodes the specified Diskinfo message, length delimited. Does not implicitly {@link Diskinfo.verify|verify} messages.
     * @function encodeDelimited
     * @memberof Diskinfo
     * @static
     * @param {IDiskinfo} message Diskinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Diskinfo.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a Diskinfo message from the specified reader or buffer.
     * @function decode
     * @memberof Diskinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {Diskinfo} Diskinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Diskinfo.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Diskinfo();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.path = reader.string();
                    break;
                }
            case 3: {
                    message.total = reader.double();
                    break;
                }
            case 4: {
                    message.free = reader.double();
                    break;
                }
            case 5: {
                    message.used = reader.double();
                    break;
                }
            case 6: {
                    message.usedPercent = reader.double();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a Diskinfo message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof Diskinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {Diskinfo} Diskinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Diskinfo.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a Diskinfo message.
     * @function verify
     * @memberof Diskinfo
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    Diskinfo.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.path != null && message.hasOwnProperty("path"))
            if (!$util.isString(message.path))
                return "path: string expected";
        if (message.total != null && message.hasOwnProperty("total"))
            if (typeof message.total !== "number")
                return "total: number expected";
        if (message.free != null && message.hasOwnProperty("free"))
            if (typeof message.free !== "number")
                return "free: number expected";
        if (message.used != null && message.hasOwnProperty("used"))
            if (typeof message.used !== "number")
                return "used: number expected";
        if (message.usedPercent != null && message.hasOwnProperty("usedPercent"))
            if (typeof message.usedPercent !== "number")
                return "usedPercent: number expected";
        return null;
    };

    /**
     * Creates a Diskinfo message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof Diskinfo
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {Diskinfo} Diskinfo
     */
    Diskinfo.fromObject = function fromObject(object) {
        if (object instanceof $root.Diskinfo)
            return object;
        let message = new $root.Diskinfo();
        if (object.name != null)
            message.name = String(object.name);
        if (object.path != null)
            message.path = String(object.path);
        if (object.total != null)
            message.total = Number(object.total);
        if (object.free != null)
            message.free = Number(object.free);
        if (object.used != null)
            message.used = Number(object.used);
        if (object.usedPercent != null)
            message.usedPercent = Number(object.usedPercent);
        return message;
    };

    /**
     * Creates a plain object from a Diskinfo message. Also converts values to other types if specified.
     * @function toObject
     * @memberof Diskinfo
     * @static
     * @param {Diskinfo} message Diskinfo
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    Diskinfo.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.path = "";
            object.total = 0;
            object.free = 0;
            object.used = 0;
            object.usedPercent = 0;
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.path != null && message.hasOwnProperty("path"))
            object.path = message.path;
        if (message.total != null && message.hasOwnProperty("total"))
            object.total = options.json && !isFinite(message.total) ? String(message.total) : message.total;
        if (message.free != null && message.hasOwnProperty("free"))
            object.free = options.json && !isFinite(message.free) ? String(message.free) : message.free;
        if (message.used != null && message.hasOwnProperty("used"))
            object.used = options.json && !isFinite(message.used) ? String(message.used) : message.used;
        if (message.usedPercent != null && message.hasOwnProperty("usedPercent"))
            object.usedPercent = options.json && !isFinite(message.usedPercent) ? String(message.usedPercent) : message.usedPercent;
        return object;
    };

    /**
     * Converts this Diskinfo to JSON.
     * @function toJSON
     * @memberof Diskinfo
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    Diskinfo.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for Diskinfo
     * @function getTypeUrl
     * @memberof Diskinfo
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    Diskinfo.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/Diskinfo";
    };

    return Diskinfo;
})();

export const Netinfo = $root.Netinfo = (() => {

    /**
     * Properties of a Netinfo.
     * @exports INetinfo
     * @interface INetinfo
     * @property {string|null} [name] Netinfo name
     * @property {number|Long|null} [bytesSent] Netinfo bytesSent
     * @property {number|Long|null} [bytesRecv] Netinfo bytesRecv
     * @property {number|Long|null} [packetsSent] Netinfo packetsSent
     * @property {number|Long|null} [packetsRecv] Netinfo packetsRecv
     */

    /**
     * Constructs a new Netinfo.
     * @exports Netinfo
     * @classdesc Represents a Netinfo.
     * @implements INetinfo
     * @constructor
     * @param {INetinfo=} [properties] Properties to set
     */
    function Netinfo(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * Netinfo name.
     * @member {string} name
     * @memberof Netinfo
     * @instance
     */
    Netinfo.prototype.name = "";

    /**
     * Netinfo bytesSent.
     * @member {number|Long} bytesSent
     * @memberof Netinfo
     * @instance
     */
    Netinfo.prototype.bytesSent = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

    /**
     * Netinfo bytesRecv.
     * @member {number|Long} bytesRecv
     * @memberof Netinfo
     * @instance
     */
    Netinfo.prototype.bytesRecv = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

    /**
     * Netinfo packetsSent.
     * @member {number|Long} packetsSent
     * @memberof Netinfo
     * @instance
     */
    Netinfo.prototype.packetsSent = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

    /**
     * Netinfo packetsRecv.
     * @member {number|Long} packetsRecv
     * @memberof Netinfo
     * @instance
     */
    Netinfo.prototype.packetsRecv = $util.Long ? $util.Long.fromBits(0,0,true) : 0;

    /**
     * Creates a new Netinfo instance using the specified properties.
     * @function create
     * @memberof Netinfo
     * @static
     * @param {INetinfo=} [properties] Properties to set
     * @returns {Netinfo} Netinfo instance
     */
    Netinfo.create = function create(properties) {
        return new Netinfo(properties);
    };

    /**
     * Encodes the specified Netinfo message. Does not implicitly {@link Netinfo.verify|verify} messages.
     * @function encode
     * @memberof Netinfo
     * @static
     * @param {INetinfo} message Netinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Netinfo.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.bytesSent != null && Object.hasOwnProperty.call(message, "bytesSent"))
            writer.uint32(/* id 2, wireType 0 =*/16).uint64(message.bytesSent);
        if (message.bytesRecv != null && Object.hasOwnProperty.call(message, "bytesRecv"))
            writer.uint32(/* id 3, wireType 0 =*/24).uint64(message.bytesRecv);
        if (message.packetsSent != null && Object.hasOwnProperty.call(message, "packetsSent"))
            writer.uint32(/* id 4, wireType 0 =*/32).uint64(message.packetsSent);
        if (message.packetsRecv != null && Object.hasOwnProperty.call(message, "packetsRecv"))
            writer.uint32(/* id 5, wireType 0 =*/40).uint64(message.packetsRecv);
        return writer;
    };

    /**
     * Encodes the specified Netinfo message, length delimited. Does not implicitly {@link Netinfo.verify|verify} messages.
     * @function encodeDelimited
     * @memberof Netinfo
     * @static
     * @param {INetinfo} message Netinfo message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    Netinfo.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a Netinfo message from the specified reader or buffer.
     * @function decode
     * @memberof Netinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {Netinfo} Netinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Netinfo.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.Netinfo();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.bytesSent = reader.uint64();
                    break;
                }
            case 3: {
                    message.bytesRecv = reader.uint64();
                    break;
                }
            case 4: {
                    message.packetsSent = reader.uint64();
                    break;
                }
            case 5: {
                    message.packetsRecv = reader.uint64();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a Netinfo message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof Netinfo
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {Netinfo} Netinfo
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    Netinfo.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a Netinfo message.
     * @function verify
     * @memberof Netinfo
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    Netinfo.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.bytesSent != null && message.hasOwnProperty("bytesSent"))
            if (!$util.isInteger(message.bytesSent) && !(message.bytesSent && $util.isInteger(message.bytesSent.low) && $util.isInteger(message.bytesSent.high)))
                return "bytesSent: integer|Long expected";
        if (message.bytesRecv != null && message.hasOwnProperty("bytesRecv"))
            if (!$util.isInteger(message.bytesRecv) && !(message.bytesRecv && $util.isInteger(message.bytesRecv.low) && $util.isInteger(message.bytesRecv.high)))
                return "bytesRecv: integer|Long expected";
        if (message.packetsSent != null && message.hasOwnProperty("packetsSent"))
            if (!$util.isInteger(message.packetsSent) && !(message.packetsSent && $util.isInteger(message.packetsSent.low) && $util.isInteger(message.packetsSent.high)))
                return "packetsSent: integer|Long expected";
        if (message.packetsRecv != null && message.hasOwnProperty("packetsRecv"))
            if (!$util.isInteger(message.packetsRecv) && !(message.packetsRecv && $util.isInteger(message.packetsRecv.low) && $util.isInteger(message.packetsRecv.high)))
                return "packetsRecv: integer|Long expected";
        return null;
    };

    /**
     * Creates a Netinfo message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof Netinfo
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {Netinfo} Netinfo
     */
    Netinfo.fromObject = function fromObject(object) {
        if (object instanceof $root.Netinfo)
            return object;
        let message = new $root.Netinfo();
        if (object.name != null)
            message.name = String(object.name);
        if (object.bytesSent != null)
            if ($util.Long)
                (message.bytesSent = $util.Long.fromValue(object.bytesSent)).unsigned = true;
            else if (typeof object.bytesSent === "string")
                message.bytesSent = parseInt(object.bytesSent, 10);
            else if (typeof object.bytesSent === "number")
                message.bytesSent = object.bytesSent;
            else if (typeof object.bytesSent === "object")
                message.bytesSent = new $util.LongBits(object.bytesSent.low >>> 0, object.bytesSent.high >>> 0).toNumber(true);
        if (object.bytesRecv != null)
            if ($util.Long)
                (message.bytesRecv = $util.Long.fromValue(object.bytesRecv)).unsigned = true;
            else if (typeof object.bytesRecv === "string")
                message.bytesRecv = parseInt(object.bytesRecv, 10);
            else if (typeof object.bytesRecv === "number")
                message.bytesRecv = object.bytesRecv;
            else if (typeof object.bytesRecv === "object")
                message.bytesRecv = new $util.LongBits(object.bytesRecv.low >>> 0, object.bytesRecv.high >>> 0).toNumber(true);
        if (object.packetsSent != null)
            if ($util.Long)
                (message.packetsSent = $util.Long.fromValue(object.packetsSent)).unsigned = true;
            else if (typeof object.packetsSent === "string")
                message.packetsSent = parseInt(object.packetsSent, 10);
            else if (typeof object.packetsSent === "number")
                message.packetsSent = object.packetsSent;
            else if (typeof object.packetsSent === "object")
                message.packetsSent = new $util.LongBits(object.packetsSent.low >>> 0, object.packetsSent.high >>> 0).toNumber(true);
        if (object.packetsRecv != null)
            if ($util.Long)
                (message.packetsRecv = $util.Long.fromValue(object.packetsRecv)).unsigned = true;
            else if (typeof object.packetsRecv === "string")
                message.packetsRecv = parseInt(object.packetsRecv, 10);
            else if (typeof object.packetsRecv === "number")
                message.packetsRecv = object.packetsRecv;
            else if (typeof object.packetsRecv === "object")
                message.packetsRecv = new $util.LongBits(object.packetsRecv.low >>> 0, object.packetsRecv.high >>> 0).toNumber(true);
        return message;
    };

    /**
     * Creates a plain object from a Netinfo message. Also converts values to other types if specified.
     * @function toObject
     * @memberof Netinfo
     * @static
     * @param {Netinfo} message Netinfo
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    Netinfo.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            if ($util.Long) {
                let long = new $util.Long(0, 0, true);
                object.bytesSent = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
            } else
                object.bytesSent = options.longs === String ? "0" : 0;
            if ($util.Long) {
                let long = new $util.Long(0, 0, true);
                object.bytesRecv = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
            } else
                object.bytesRecv = options.longs === String ? "0" : 0;
            if ($util.Long) {
                let long = new $util.Long(0, 0, true);
                object.packetsSent = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
            } else
                object.packetsSent = options.longs === String ? "0" : 0;
            if ($util.Long) {
                let long = new $util.Long(0, 0, true);
                object.packetsRecv = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
            } else
                object.packetsRecv = options.longs === String ? "0" : 0;
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.bytesSent != null && message.hasOwnProperty("bytesSent"))
            if (typeof message.bytesSent === "number")
                object.bytesSent = options.longs === String ? String(message.bytesSent) : message.bytesSent;
            else
                object.bytesSent = options.longs === String ? $util.Long.prototype.toString.call(message.bytesSent) : options.longs === Number ? new $util.LongBits(message.bytesSent.low >>> 0, message.bytesSent.high >>> 0).toNumber(true) : message.bytesSent;
        if (message.bytesRecv != null && message.hasOwnProperty("bytesRecv"))
            if (typeof message.bytesRecv === "number")
                object.bytesRecv = options.longs === String ? String(message.bytesRecv) : message.bytesRecv;
            else
                object.bytesRecv = options.longs === String ? $util.Long.prototype.toString.call(message.bytesRecv) : options.longs === Number ? new $util.LongBits(message.bytesRecv.low >>> 0, message.bytesRecv.high >>> 0).toNumber(true) : message.bytesRecv;
        if (message.packetsSent != null && message.hasOwnProperty("packetsSent"))
            if (typeof message.packetsSent === "number")
                object.packetsSent = options.longs === String ? String(message.packetsSent) : message.packetsSent;
            else
                object.packetsSent = options.longs === String ? $util.Long.prototype.toString.call(message.packetsSent) : options.longs === Number ? new $util.LongBits(message.packetsSent.low >>> 0, message.packetsSent.high >>> 0).toNumber(true) : message.packetsSent;
        if (message.packetsRecv != null && message.hasOwnProperty("packetsRecv"))
            if (typeof message.packetsRecv === "number")
                object.packetsRecv = options.longs === String ? String(message.packetsRecv) : message.packetsRecv;
            else
                object.packetsRecv = options.longs === String ? $util.Long.prototype.toString.call(message.packetsRecv) : options.longs === Number ? new $util.LongBits(message.packetsRecv.low >>> 0, message.packetsRecv.high >>> 0).toNumber(true) : message.packetsRecv;
        return object;
    };

    /**
     * Converts this Netinfo to JSON.
     * @function toJSON
     * @memberof Netinfo
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    Netinfo.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for Netinfo
     * @function getTypeUrl
     * @memberof Netinfo
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    Netinfo.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/Netinfo";
    };

    return Netinfo;
})();

export const net_info = $root.net_info = (() => {

    /**
     * Properties of a net_info.
     * @exports Inet_info
     * @interface Inet_info
     * @property {Array.<Iip_info>|null} [ip] net_info ip
     * @property {Idns_info|null} [dns] net_info dns
     */

    /**
     * Constructs a new net_info.
     * @exports net_info
     * @classdesc Represents a net_info.
     * @implements Inet_info
     * @constructor
     * @param {Inet_info=} [properties] Properties to set
     */
    function net_info(properties) {
        this.ip = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * net_info ip.
     * @member {Array.<Iip_info>} ip
     * @memberof net_info
     * @instance
     */
    net_info.prototype.ip = $util.emptyArray;

    /**
     * net_info dns.
     * @member {Idns_info|null|undefined} dns
     * @memberof net_info
     * @instance
     */
    net_info.prototype.dns = null;

    /**
     * Creates a new net_info instance using the specified properties.
     * @function create
     * @memberof net_info
     * @static
     * @param {Inet_info=} [properties] Properties to set
     * @returns {net_info} net_info instance
     */
    net_info.create = function create(properties) {
        return new net_info(properties);
    };

    /**
     * Encodes the specified net_info message. Does not implicitly {@link net_info.verify|verify} messages.
     * @function encode
     * @memberof net_info
     * @static
     * @param {Inet_info} message net_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    net_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.ip != null && message.ip.length)
            for (let i = 0; i < message.ip.length; ++i)
                $root.ip_info.encode(message.ip[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        if (message.dns != null && Object.hasOwnProperty.call(message, "dns"))
            $root.dns_info.encode(message.dns, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified net_info message, length delimited. Does not implicitly {@link net_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof net_info
     * @static
     * @param {Inet_info} message net_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    net_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a net_info message from the specified reader or buffer.
     * @function decode
     * @memberof net_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {net_info} net_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    net_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.net_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.ip && message.ip.length))
                        message.ip = [];
                    message.ip.push($root.ip_info.decode(reader, reader.uint32()));
                    break;
                }
            case 2: {
                    message.dns = $root.dns_info.decode(reader, reader.uint32());
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a net_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof net_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {net_info} net_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    net_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a net_info message.
     * @function verify
     * @memberof net_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    net_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.ip != null && message.hasOwnProperty("ip")) {
            if (!Array.isArray(message.ip))
                return "ip: array expected";
            for (let i = 0; i < message.ip.length; ++i) {
                let error = $root.ip_info.verify(message.ip[i]);
                if (error)
                    return "ip." + error;
            }
        }
        if (message.dns != null && message.hasOwnProperty("dns")) {
            let error = $root.dns_info.verify(message.dns);
            if (error)
                return "dns." + error;
        }
        return null;
    };

    /**
     * Creates a net_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof net_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {net_info} net_info
     */
    net_info.fromObject = function fromObject(object) {
        if (object instanceof $root.net_info)
            return object;
        let message = new $root.net_info();
        if (object.ip) {
            if (!Array.isArray(object.ip))
                throw TypeError(".net_info.ip: array expected");
            message.ip = [];
            for (let i = 0; i < object.ip.length; ++i) {
                if (typeof object.ip[i] !== "object")
                    throw TypeError(".net_info.ip: object expected");
                message.ip[i] = $root.ip_info.fromObject(object.ip[i]);
            }
        }
        if (object.dns != null) {
            if (typeof object.dns !== "object")
                throw TypeError(".net_info.dns: object expected");
            message.dns = $root.dns_info.fromObject(object.dns);
        }
        return message;
    };

    /**
     * Creates a plain object from a net_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof net_info
     * @static
     * @param {net_info} message net_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    net_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.ip = [];
        if (options.defaults)
            object.dns = null;
        if (message.ip && message.ip.length) {
            object.ip = [];
            for (let j = 0; j < message.ip.length; ++j)
                object.ip[j] = $root.ip_info.toObject(message.ip[j], options);
        }
        if (message.dns != null && message.hasOwnProperty("dns"))
            object.dns = $root.dns_info.toObject(message.dns, options);
        return object;
    };

    /**
     * Converts this net_info to JSON.
     * @function toJSON
     * @memberof net_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    net_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for net_info
     * @function getTypeUrl
     * @memberof net_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    net_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/net_info";
    };

    return net_info;
})();

export const ip_info = $root.ip_info = (() => {

    /**
     * Properties of an ip_info.
     * @exports Iip_info
     * @interface Iip_info
     * @property {string|null} [name] ip_info name
     * @property {string|null} [mode] ip_info mode
     * @property {string|null} [ip] ip_info ip
     * @property {string|null} [mk] ip_info mk
     * @property {string|null} [gw] ip_info gw
     */

    /**
     * Constructs a new ip_info.
     * @exports ip_info
     * @classdesc Represents an ip_info.
     * @implements Iip_info
     * @constructor
     * @param {Iip_info=} [properties] Properties to set
     */
    function ip_info(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * ip_info name.
     * @member {string} name
     * @memberof ip_info
     * @instance
     */
    ip_info.prototype.name = "";

    /**
     * ip_info mode.
     * @member {string} mode
     * @memberof ip_info
     * @instance
     */
    ip_info.prototype.mode = "";

    /**
     * ip_info ip.
     * @member {string} ip
     * @memberof ip_info
     * @instance
     */
    ip_info.prototype.ip = "";

    /**
     * ip_info mk.
     * @member {string} mk
     * @memberof ip_info
     * @instance
     */
    ip_info.prototype.mk = "";

    /**
     * ip_info gw.
     * @member {string} gw
     * @memberof ip_info
     * @instance
     */
    ip_info.prototype.gw = "";

    /**
     * Creates a new ip_info instance using the specified properties.
     * @function create
     * @memberof ip_info
     * @static
     * @param {Iip_info=} [properties] Properties to set
     * @returns {ip_info} ip_info instance
     */
    ip_info.create = function create(properties) {
        return new ip_info(properties);
    };

    /**
     * Encodes the specified ip_info message. Does not implicitly {@link ip_info.verify|verify} messages.
     * @function encode
     * @memberof ip_info
     * @static
     * @param {Iip_info} message ip_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    ip_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.mode != null && Object.hasOwnProperty.call(message, "mode"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.mode);
        if (message.ip != null && Object.hasOwnProperty.call(message, "ip"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.ip);
        if (message.mk != null && Object.hasOwnProperty.call(message, "mk"))
            writer.uint32(/* id 4, wireType 2 =*/34).string(message.mk);
        if (message.gw != null && Object.hasOwnProperty.call(message, "gw"))
            writer.uint32(/* id 5, wireType 2 =*/42).string(message.gw);
        return writer;
    };

    /**
     * Encodes the specified ip_info message, length delimited. Does not implicitly {@link ip_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof ip_info
     * @static
     * @param {Iip_info} message ip_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    ip_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes an ip_info message from the specified reader or buffer.
     * @function decode
     * @memberof ip_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {ip_info} ip_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    ip_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.ip_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.mode = reader.string();
                    break;
                }
            case 3: {
                    message.ip = reader.string();
                    break;
                }
            case 4: {
                    message.mk = reader.string();
                    break;
                }
            case 5: {
                    message.gw = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes an ip_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof ip_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {ip_info} ip_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    ip_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies an ip_info message.
     * @function verify
     * @memberof ip_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    ip_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.mode != null && message.hasOwnProperty("mode"))
            if (!$util.isString(message.mode))
                return "mode: string expected";
        if (message.ip != null && message.hasOwnProperty("ip"))
            if (!$util.isString(message.ip))
                return "ip: string expected";
        if (message.mk != null && message.hasOwnProperty("mk"))
            if (!$util.isString(message.mk))
                return "mk: string expected";
        if (message.gw != null && message.hasOwnProperty("gw"))
            if (!$util.isString(message.gw))
                return "gw: string expected";
        return null;
    };

    /**
     * Creates an ip_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof ip_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {ip_info} ip_info
     */
    ip_info.fromObject = function fromObject(object) {
        if (object instanceof $root.ip_info)
            return object;
        let message = new $root.ip_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.mode != null)
            message.mode = String(object.mode);
        if (object.ip != null)
            message.ip = String(object.ip);
        if (object.mk != null)
            message.mk = String(object.mk);
        if (object.gw != null)
            message.gw = String(object.gw);
        return message;
    };

    /**
     * Creates a plain object from an ip_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof ip_info
     * @static
     * @param {ip_info} message ip_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    ip_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.mode = "";
            object.ip = "";
            object.mk = "";
            object.gw = "";
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.mode != null && message.hasOwnProperty("mode"))
            object.mode = message.mode;
        if (message.ip != null && message.hasOwnProperty("ip"))
            object.ip = message.ip;
        if (message.mk != null && message.hasOwnProperty("mk"))
            object.mk = message.mk;
        if (message.gw != null && message.hasOwnProperty("gw"))
            object.gw = message.gw;
        return object;
    };

    /**
     * Converts this ip_info to JSON.
     * @function toJSON
     * @memberof ip_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    ip_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for ip_info
     * @function getTypeUrl
     * @memberof ip_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    ip_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/ip_info";
    };

    return ip_info;
})();

export const dns_info = $root.dns_info = (() => {

    /**
     * Properties of a dns_info.
     * @exports Idns_info
     * @interface Idns_info
     * @property {string|null} [dns1] dns_info dns1
     * @property {string|null} [dns2] dns_info dns2
     */

    /**
     * Constructs a new dns_info.
     * @exports dns_info
     * @classdesc Represents a dns_info.
     * @implements Idns_info
     * @constructor
     * @param {Idns_info=} [properties] Properties to set
     */
    function dns_info(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * dns_info dns1.
     * @member {string} dns1
     * @memberof dns_info
     * @instance
     */
    dns_info.prototype.dns1 = "";

    /**
     * dns_info dns2.
     * @member {string} dns2
     * @memberof dns_info
     * @instance
     */
    dns_info.prototype.dns2 = "";

    /**
     * Creates a new dns_info instance using the specified properties.
     * @function create
     * @memberof dns_info
     * @static
     * @param {Idns_info=} [properties] Properties to set
     * @returns {dns_info} dns_info instance
     */
    dns_info.create = function create(properties) {
        return new dns_info(properties);
    };

    /**
     * Encodes the specified dns_info message. Does not implicitly {@link dns_info.verify|verify} messages.
     * @function encode
     * @memberof dns_info
     * @static
     * @param {Idns_info} message dns_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    dns_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.dns1 != null && Object.hasOwnProperty.call(message, "dns1"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.dns1);
        if (message.dns2 != null && Object.hasOwnProperty.call(message, "dns2"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.dns2);
        return writer;
    };

    /**
     * Encodes the specified dns_info message, length delimited. Does not implicitly {@link dns_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof dns_info
     * @static
     * @param {Idns_info} message dns_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    dns_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a dns_info message from the specified reader or buffer.
     * @function decode
     * @memberof dns_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {dns_info} dns_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    dns_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.dns_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.dns1 = reader.string();
                    break;
                }
            case 2: {
                    message.dns2 = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a dns_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof dns_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {dns_info} dns_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    dns_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a dns_info message.
     * @function verify
     * @memberof dns_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    dns_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.dns1 != null && message.hasOwnProperty("dns1"))
            if (!$util.isString(message.dns1))
                return "dns1: string expected";
        if (message.dns2 != null && message.hasOwnProperty("dns2"))
            if (!$util.isString(message.dns2))
                return "dns2: string expected";
        return null;
    };

    /**
     * Creates a dns_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof dns_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {dns_info} dns_info
     */
    dns_info.fromObject = function fromObject(object) {
        if (object instanceof $root.dns_info)
            return object;
        let message = new $root.dns_info();
        if (object.dns1 != null)
            message.dns1 = String(object.dns1);
        if (object.dns2 != null)
            message.dns2 = String(object.dns2);
        return message;
    };

    /**
     * Creates a plain object from a dns_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof dns_info
     * @static
     * @param {dns_info} message dns_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    dns_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.dns1 = "";
            object.dns2 = "";
        }
        if (message.dns1 != null && message.hasOwnProperty("dns1"))
            object.dns1 = message.dns1;
        if (message.dns2 != null && message.hasOwnProperty("dns2"))
            object.dns2 = message.dns2;
        return object;
    };

    /**
     * Converts this dns_info to JSON.
     * @function toJSON
     * @memberof dns_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    dns_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for dns_info
     * @function getTypeUrl
     * @memberof dns_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    dns_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/dns_info";
    };

    return dns_info;
})();

export const response = $root.response = (() => {

    /**
     * Properties of a response.
     * @exports Iresponse
     * @interface Iresponse
     * @property {number|null} [code] response code
     * @property {Uint8Array|null} [data] response data
     * @property {string|null} [msg] response msg
     */

    /**
     * Constructs a new response.
     * @exports response
     * @classdesc Represents a response.
     * @implements Iresponse
     * @constructor
     * @param {Iresponse=} [properties] Properties to set
     */
    function response(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * response code.
     * @member {number} code
     * @memberof response
     * @instance
     */
    response.prototype.code = 0;

    /**
     * response data.
     * @member {Uint8Array} data
     * @memberof response
     * @instance
     */
    response.prototype.data = $util.newBuffer([]);

    /**
     * response msg.
     * @member {string} msg
     * @memberof response
     * @instance
     */
    response.prototype.msg = "";

    /**
     * Creates a new response instance using the specified properties.
     * @function create
     * @memberof response
     * @static
     * @param {Iresponse=} [properties] Properties to set
     * @returns {response} response instance
     */
    response.create = function create(properties) {
        return new response(properties);
    };

    /**
     * Encodes the specified response message. Does not implicitly {@link response.verify|verify} messages.
     * @function encode
     * @memberof response
     * @static
     * @param {Iresponse} message response message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    response.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.code != null && Object.hasOwnProperty.call(message, "code"))
            writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.code);
        if (message.data != null && Object.hasOwnProperty.call(message, "data"))
            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.data);
        if (message.msg != null && Object.hasOwnProperty.call(message, "msg"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.msg);
        return writer;
    };

    /**
     * Encodes the specified response message, length delimited. Does not implicitly {@link response.verify|verify} messages.
     * @function encodeDelimited
     * @memberof response
     * @static
     * @param {Iresponse} message response message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    response.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a response message from the specified reader or buffer.
     * @function decode
     * @memberof response
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {response} response
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    response.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.response();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.code = reader.uint32();
                    break;
                }
            case 2: {
                    message.data = reader.bytes();
                    break;
                }
            case 3: {
                    message.msg = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a response message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof response
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {response} response
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    response.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a response message.
     * @function verify
     * @memberof response
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    response.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.code != null && message.hasOwnProperty("code"))
            if (!$util.isInteger(message.code))
                return "code: integer expected";
        if (message.data != null && message.hasOwnProperty("data"))
            if (!(message.data && typeof message.data.length === "number" || $util.isString(message.data)))
                return "data: buffer expected";
        if (message.msg != null && message.hasOwnProperty("msg"))
            if (!$util.isString(message.msg))
                return "msg: string expected";
        return null;
    };

    /**
     * Creates a response message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof response
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {response} response
     */
    response.fromObject = function fromObject(object) {
        if (object instanceof $root.response)
            return object;
        let message = new $root.response();
        if (object.code != null)
            message.code = object.code >>> 0;
        if (object.data != null)
            if (typeof object.data === "string")
                $util.base64.decode(object.data, message.data = $util.newBuffer($util.base64.length(object.data)), 0);
            else if (object.data.length >= 0)
                message.data = object.data;
        if (object.msg != null)
            message.msg = String(object.msg);
        return message;
    };

    /**
     * Creates a plain object from a response message. Also converts values to other types if specified.
     * @function toObject
     * @memberof response
     * @static
     * @param {response} message response
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    response.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.code = 0;
            if (options.bytes === String)
                object.data = "";
            else {
                object.data = [];
                if (options.bytes !== Array)
                    object.data = $util.newBuffer(object.data);
            }
            object.msg = "";
        }
        if (message.code != null && message.hasOwnProperty("code"))
            object.code = message.code;
        if (message.data != null && message.hasOwnProperty("data"))
            object.data = options.bytes === String ? $util.base64.encode(message.data, 0, message.data.length) : options.bytes === Array ? Array.prototype.slice.call(message.data) : message.data;
        if (message.msg != null && message.hasOwnProperty("msg"))
            object.msg = message.msg;
        return object;
    };

    /**
     * Converts this response to JSON.
     * @function toJSON
     * @memberof response
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    response.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for response
     * @function getTypeUrl
     * @memberof response
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    response.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/response";
    };

    return response;
})();

export const sb_list = $root.sb_list = (() => {

    /**
     * Properties of a sb_list.
     * @exports Isb_list
     * @interface Isb_list
     * @property {Array.<Isb_info>|null} [sb] sb_list sb
     */

    /**
     * Constructs a new sb_list.
     * @exports sb_list
     * @classdesc Represents a sb_list.
     * @implements Isb_list
     * @constructor
     * @param {Isb_list=} [properties] Properties to set
     */
    function sb_list(properties) {
        this.sb = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * sb_list sb.
     * @member {Array.<Isb_info>} sb
     * @memberof sb_list
     * @instance
     */
    sb_list.prototype.sb = $util.emptyArray;

    /**
     * Creates a new sb_list instance using the specified properties.
     * @function create
     * @memberof sb_list
     * @static
     * @param {Isb_list=} [properties] Properties to set
     * @returns {sb_list} sb_list instance
     */
    sb_list.create = function create(properties) {
        return new sb_list(properties);
    };

    /**
     * Encodes the specified sb_list message. Does not implicitly {@link sb_list.verify|verify} messages.
     * @function encode
     * @memberof sb_list
     * @static
     * @param {Isb_list} message sb_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.sb != null && message.sb.length)
            for (let i = 0; i < message.sb.length; ++i)
                $root.sb_info.encode(message.sb[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified sb_list message, length delimited. Does not implicitly {@link sb_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof sb_list
     * @static
     * @param {Isb_list} message sb_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a sb_list message from the specified reader or buffer.
     * @function decode
     * @memberof sb_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {sb_list} sb_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sb_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.sb && message.sb.length))
                        message.sb = [];
                    message.sb.push($root.sb_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a sb_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof sb_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {sb_list} sb_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a sb_list message.
     * @function verify
     * @memberof sb_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    sb_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.sb != null && message.hasOwnProperty("sb")) {
            if (!Array.isArray(message.sb))
                return "sb: array expected";
            for (let i = 0; i < message.sb.length; ++i) {
                let error = $root.sb_info.verify(message.sb[i]);
                if (error)
                    return "sb." + error;
            }
        }
        return null;
    };

    /**
     * Creates a sb_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof sb_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {sb_list} sb_list
     */
    sb_list.fromObject = function fromObject(object) {
        if (object instanceof $root.sb_list)
            return object;
        let message = new $root.sb_list();
        if (object.sb) {
            if (!Array.isArray(object.sb))
                throw TypeError(".sb_list.sb: array expected");
            message.sb = [];
            for (let i = 0; i < object.sb.length; ++i) {
                if (typeof object.sb[i] !== "object")
                    throw TypeError(".sb_list.sb: object expected");
                message.sb[i] = $root.sb_info.fromObject(object.sb[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a sb_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof sb_list
     * @static
     * @param {sb_list} message sb_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    sb_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.sb = [];
        if (message.sb && message.sb.length) {
            object.sb = [];
            for (let j = 0; j < message.sb.length; ++j)
                object.sb[j] = $root.sb_info.toObject(message.sb[j], options);
        }
        return object;
    };

    /**
     * Converts this sb_list to JSON.
     * @function toJSON
     * @memberof sb_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    sb_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for sb_list
     * @function getTypeUrl
     * @memberof sb_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    sb_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/sb_list";
    };

    return sb_list;
})();

export const sb_host = $root.sb_host = (() => {

    /**
     * Properties of a sb_host.
     * @exports Isb_host
     * @interface Isb_host
     * @property {Array.<string>|null} [host] sb_host host
     */

    /**
     * Constructs a new sb_host.
     * @exports sb_host
     * @classdesc Represents a sb_host.
     * @implements Isb_host
     * @constructor
     * @param {Isb_host=} [properties] Properties to set
     */
    function sb_host(properties) {
        this.host = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * sb_host host.
     * @member {Array.<string>} host
     * @memberof sb_host
     * @instance
     */
    sb_host.prototype.host = $util.emptyArray;

    /**
     * Creates a new sb_host instance using the specified properties.
     * @function create
     * @memberof sb_host
     * @static
     * @param {Isb_host=} [properties] Properties to set
     * @returns {sb_host} sb_host instance
     */
    sb_host.create = function create(properties) {
        return new sb_host(properties);
    };

    /**
     * Encodes the specified sb_host message. Does not implicitly {@link sb_host.verify|verify} messages.
     * @function encode
     * @memberof sb_host
     * @static
     * @param {Isb_host} message sb_host message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_host.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.host != null && message.host.length)
            for (let i = 0; i < message.host.length; ++i)
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.host[i]);
        return writer;
    };

    /**
     * Encodes the specified sb_host message, length delimited. Does not implicitly {@link sb_host.verify|verify} messages.
     * @function encodeDelimited
     * @memberof sb_host
     * @static
     * @param {Isb_host} message sb_host message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_host.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a sb_host message from the specified reader or buffer.
     * @function decode
     * @memberof sb_host
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {sb_host} sb_host
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_host.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sb_host();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.host && message.host.length))
                        message.host = [];
                    message.host.push(reader.string());
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a sb_host message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof sb_host
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {sb_host} sb_host
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_host.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a sb_host message.
     * @function verify
     * @memberof sb_host
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    sb_host.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.host != null && message.hasOwnProperty("host")) {
            if (!Array.isArray(message.host))
                return "host: array expected";
            for (let i = 0; i < message.host.length; ++i)
                if (!$util.isString(message.host[i]))
                    return "host: string[] expected";
        }
        return null;
    };

    /**
     * Creates a sb_host message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof sb_host
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {sb_host} sb_host
     */
    sb_host.fromObject = function fromObject(object) {
        if (object instanceof $root.sb_host)
            return object;
        let message = new $root.sb_host();
        if (object.host) {
            if (!Array.isArray(object.host))
                throw TypeError(".sb_host.host: array expected");
            message.host = [];
            for (let i = 0; i < object.host.length; ++i)
                message.host[i] = String(object.host[i]);
        }
        return message;
    };

    /**
     * Creates a plain object from a sb_host message. Also converts values to other types if specified.
     * @function toObject
     * @memberof sb_host
     * @static
     * @param {sb_host} message sb_host
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    sb_host.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.host = [];
        if (message.host && message.host.length) {
            object.host = [];
            for (let j = 0; j < message.host.length; ++j)
                object.host[j] = message.host[j];
        }
        return object;
    };

    /**
     * Converts this sb_host to JSON.
     * @function toJSON
     * @memberof sb_host
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    sb_host.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for sb_host
     * @function getTypeUrl
     * @memberof sb_host
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    sb_host.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/sb_host";
    };

    return sb_host;
})();

export const sb_info = $root.sb_info = (() => {

    /**
     * Properties of a sb_info.
     * @exports Isb_info
     * @interface Isb_info
     * @property {string|null} [name] sb_info name
     * @property {string|null} [drive] sb_info drive
     * @property {string|null} [host] sb_info host
     * @property {number|null} [status] sb_info status
     * @property {string|null} [description] sb_info description
     * @property {boolean|null} [enable] sb_info enable
     * @property {Array.<string>|null} [deviceName] sb_info deviceName
     */

    /**
     * Constructs a new sb_info.
     * @exports sb_info
     * @classdesc Represents a sb_info.
     * @implements Isb_info
     * @constructor
     * @param {Isb_info=} [properties] Properties to set
     */
    function sb_info(properties) {
        this.deviceName = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * sb_info name.
     * @member {string} name
     * @memberof sb_info
     * @instance
     */
    sb_info.prototype.name = "";

    /**
     * sb_info drive.
     * @member {string} drive
     * @memberof sb_info
     * @instance
     */
    sb_info.prototype.drive = "";

    /**
     * sb_info host.
     * @member {string} host
     * @memberof sb_info
     * @instance
     */
    sb_info.prototype.host = "";

    /**
     * sb_info status.
     * @member {number} status
     * @memberof sb_info
     * @instance
     */
    sb_info.prototype.status = 0;

    /**
     * sb_info description.
     * @member {string} description
     * @memberof sb_info
     * @instance
     */
    sb_info.prototype.description = "";

    /**
     * sb_info enable.
     * @member {boolean} enable
     * @memberof sb_info
     * @instance
     */
    sb_info.prototype.enable = false;

    /**
     * sb_info deviceName.
     * @member {Array.<string>} deviceName
     * @memberof sb_info
     * @instance
     */
    sb_info.prototype.deviceName = $util.emptyArray;

    /**
     * Creates a new sb_info instance using the specified properties.
     * @function create
     * @memberof sb_info
     * @static
     * @param {Isb_info=} [properties] Properties to set
     * @returns {sb_info} sb_info instance
     */
    sb_info.create = function create(properties) {
        return new sb_info(properties);
    };

    /**
     * Encodes the specified sb_info message. Does not implicitly {@link sb_info.verify|verify} messages.
     * @function encode
     * @memberof sb_info
     * @static
     * @param {Isb_info} message sb_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.drive != null && Object.hasOwnProperty.call(message, "drive"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.drive);
        if (message.host != null && Object.hasOwnProperty.call(message, "host"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.host);
        if (message.status != null && Object.hasOwnProperty.call(message, "status"))
            writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.status);
        if (message.description != null && Object.hasOwnProperty.call(message, "description"))
            writer.uint32(/* id 5, wireType 2 =*/42).string(message.description);
        if (message.enable != null && Object.hasOwnProperty.call(message, "enable"))
            writer.uint32(/* id 6, wireType 0 =*/48).bool(message.enable);
        if (message.deviceName != null && message.deviceName.length)
            for (let i = 0; i < message.deviceName.length; ++i)
                writer.uint32(/* id 7, wireType 2 =*/58).string(message.deviceName[i]);
        return writer;
    };

    /**
     * Encodes the specified sb_info message, length delimited. Does not implicitly {@link sb_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof sb_info
     * @static
     * @param {Isb_info} message sb_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a sb_info message from the specified reader or buffer.
     * @function decode
     * @memberof sb_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {sb_info} sb_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sb_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.drive = reader.string();
                    break;
                }
            case 3: {
                    message.host = reader.string();
                    break;
                }
            case 4: {
                    message.status = reader.uint32();
                    break;
                }
            case 5: {
                    message.description = reader.string();
                    break;
                }
            case 6: {
                    message.enable = reader.bool();
                    break;
                }
            case 7: {
                    if (!(message.deviceName && message.deviceName.length))
                        message.deviceName = [];
                    message.deviceName.push(reader.string());
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a sb_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof sb_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {sb_info} sb_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a sb_info message.
     * @function verify
     * @memberof sb_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    sb_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.drive != null && message.hasOwnProperty("drive"))
            if (!$util.isString(message.drive))
                return "drive: string expected";
        if (message.host != null && message.hasOwnProperty("host"))
            if (!$util.isString(message.host))
                return "host: string expected";
        if (message.status != null && message.hasOwnProperty("status"))
            if (!$util.isInteger(message.status))
                return "status: integer expected";
        if (message.description != null && message.hasOwnProperty("description"))
            if (!$util.isString(message.description))
                return "description: string expected";
        if (message.enable != null && message.hasOwnProperty("enable"))
            if (typeof message.enable !== "boolean")
                return "enable: boolean expected";
        if (message.deviceName != null && message.hasOwnProperty("deviceName")) {
            if (!Array.isArray(message.deviceName))
                return "deviceName: array expected";
            for (let i = 0; i < message.deviceName.length; ++i)
                if (!$util.isString(message.deviceName[i]))
                    return "deviceName: string[] expected";
        }
        return null;
    };

    /**
     * Creates a sb_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof sb_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {sb_info} sb_info
     */
    sb_info.fromObject = function fromObject(object) {
        if (object instanceof $root.sb_info)
            return object;
        let message = new $root.sb_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.drive != null)
            message.drive = String(object.drive);
        if (object.host != null)
            message.host = String(object.host);
        if (object.status != null)
            message.status = object.status >>> 0;
        if (object.description != null)
            message.description = String(object.description);
        if (object.enable != null)
            message.enable = Boolean(object.enable);
        if (object.deviceName) {
            if (!Array.isArray(object.deviceName))
                throw TypeError(".sb_info.deviceName: array expected");
            message.deviceName = [];
            for (let i = 0; i < object.deviceName.length; ++i)
                message.deviceName[i] = String(object.deviceName[i]);
        }
        return message;
    };

    /**
     * Creates a plain object from a sb_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof sb_info
     * @static
     * @param {sb_info} message sb_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    sb_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.deviceName = [];
        if (options.defaults) {
            object.name = "";
            object.drive = "";
            object.host = "";
            object.status = 0;
            object.description = "";
            object.enable = false;
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.drive != null && message.hasOwnProperty("drive"))
            object.drive = message.drive;
        if (message.host != null && message.hasOwnProperty("host"))
            object.host = message.host;
        if (message.status != null && message.hasOwnProperty("status"))
            object.status = message.status;
        if (message.description != null && message.hasOwnProperty("description"))
            object.description = message.description;
        if (message.enable != null && message.hasOwnProperty("enable"))
            object.enable = message.enable;
        if (message.deviceName && message.deviceName.length) {
            object.deviceName = [];
            for (let j = 0; j < message.deviceName.length; ++j)
                object.deviceName[j] = message.deviceName[j];
        }
        return object;
    };

    /**
     * Converts this sb_info to JSON.
     * @function toJSON
     * @memberof sb_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    sb_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for sb_info
     * @function getTypeUrl
     * @memberof sb_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    sb_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/sb_info";
    };

    return sb_info;
})();

export const sb_add = $root.sb_add = (() => {

    /**
     * Properties of a sb_add.
     * @exports Isb_add
     * @interface Isb_add
     * @property {string|null} [name] sb_add name
     * @property {string|null} [drive] sb_add drive
     * @property {string|null} [description] sb_add description
     * @property {Uint8Array|null} [config] sb_add config
     */

    /**
     * Constructs a new sb_add.
     * @exports sb_add
     * @classdesc Represents a sb_add.
     * @implements Isb_add
     * @constructor
     * @param {Isb_add=} [properties] Properties to set
     */
    function sb_add(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * sb_add name.
     * @member {string} name
     * @memberof sb_add
     * @instance
     */
    sb_add.prototype.name = "";

    /**
     * sb_add drive.
     * @member {string} drive
     * @memberof sb_add
     * @instance
     */
    sb_add.prototype.drive = "";

    /**
     * sb_add description.
     * @member {string} description
     * @memberof sb_add
     * @instance
     */
    sb_add.prototype.description = "";

    /**
     * sb_add config.
     * @member {Uint8Array} config
     * @memberof sb_add
     * @instance
     */
    sb_add.prototype.config = $util.newBuffer([]);

    /**
     * Creates a new sb_add instance using the specified properties.
     * @function create
     * @memberof sb_add
     * @static
     * @param {Isb_add=} [properties] Properties to set
     * @returns {sb_add} sb_add instance
     */
    sb_add.create = function create(properties) {
        return new sb_add(properties);
    };

    /**
     * Encodes the specified sb_add message. Does not implicitly {@link sb_add.verify|verify} messages.
     * @function encode
     * @memberof sb_add
     * @static
     * @param {Isb_add} message sb_add message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_add.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.drive != null && Object.hasOwnProperty.call(message, "drive"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.drive);
        if (message.description != null && Object.hasOwnProperty.call(message, "description"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.description);
        if (message.config != null && Object.hasOwnProperty.call(message, "config"))
            writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.config);
        return writer;
    };

    /**
     * Encodes the specified sb_add message, length delimited. Does not implicitly {@link sb_add.verify|verify} messages.
     * @function encodeDelimited
     * @memberof sb_add
     * @static
     * @param {Isb_add} message sb_add message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_add.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a sb_add message from the specified reader or buffer.
     * @function decode
     * @memberof sb_add
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {sb_add} sb_add
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_add.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sb_add();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.drive = reader.string();
                    break;
                }
            case 3: {
                    message.description = reader.string();
                    break;
                }
            case 4: {
                    message.config = reader.bytes();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a sb_add message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof sb_add
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {sb_add} sb_add
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_add.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a sb_add message.
     * @function verify
     * @memberof sb_add
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    sb_add.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.drive != null && message.hasOwnProperty("drive"))
            if (!$util.isString(message.drive))
                return "drive: string expected";
        if (message.description != null && message.hasOwnProperty("description"))
            if (!$util.isString(message.description))
                return "description: string expected";
        if (message.config != null && message.hasOwnProperty("config"))
            if (!(message.config && typeof message.config.length === "number" || $util.isString(message.config)))
                return "config: buffer expected";
        return null;
    };

    /**
     * Creates a sb_add message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof sb_add
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {sb_add} sb_add
     */
    sb_add.fromObject = function fromObject(object) {
        if (object instanceof $root.sb_add)
            return object;
        let message = new $root.sb_add();
        if (object.name != null)
            message.name = String(object.name);
        if (object.drive != null)
            message.drive = String(object.drive);
        if (object.description != null)
            message.description = String(object.description);
        if (object.config != null)
            if (typeof object.config === "string")
                $util.base64.decode(object.config, message.config = $util.newBuffer($util.base64.length(object.config)), 0);
            else if (object.config.length >= 0)
                message.config = object.config;
        return message;
    };

    /**
     * Creates a plain object from a sb_add message. Also converts values to other types if specified.
     * @function toObject
     * @memberof sb_add
     * @static
     * @param {sb_add} message sb_add
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    sb_add.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.drive = "";
            object.description = "";
            if (options.bytes === String)
                object.config = "";
            else {
                object.config = [];
                if (options.bytes !== Array)
                    object.config = $util.newBuffer(object.config);
            }
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.drive != null && message.hasOwnProperty("drive"))
            object.drive = message.drive;
        if (message.description != null && message.hasOwnProperty("description"))
            object.description = message.description;
        if (message.config != null && message.hasOwnProperty("config"))
            object.config = options.bytes === String ? $util.base64.encode(message.config, 0, message.config.length) : options.bytes === Array ? Array.prototype.slice.call(message.config) : message.config;
        return object;
    };

    /**
     * Converts this sb_add to JSON.
     * @function toJSON
     * @memberof sb_add
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    sb_add.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for sb_add
     * @function getTypeUrl
     * @memberof sb_add
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    sb_add.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/sb_add";
    };

    return sb_add;
})();

export const sb_drive_list = $root.sb_drive_list = (() => {

    /**
     * Properties of a sb_drive_list.
     * @exports Isb_drive_list
     * @interface Isb_drive_list
     * @property {Array.<Isb_drive_info>|null} [sbDrive] sb_drive_list sbDrive
     */

    /**
     * Constructs a new sb_drive_list.
     * @exports sb_drive_list
     * @classdesc Represents a sb_drive_list.
     * @implements Isb_drive_list
     * @constructor
     * @param {Isb_drive_list=} [properties] Properties to set
     */
    function sb_drive_list(properties) {
        this.sbDrive = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * sb_drive_list sbDrive.
     * @member {Array.<Isb_drive_info>} sbDrive
     * @memberof sb_drive_list
     * @instance
     */
    sb_drive_list.prototype.sbDrive = $util.emptyArray;

    /**
     * Creates a new sb_drive_list instance using the specified properties.
     * @function create
     * @memberof sb_drive_list
     * @static
     * @param {Isb_drive_list=} [properties] Properties to set
     * @returns {sb_drive_list} sb_drive_list instance
     */
    sb_drive_list.create = function create(properties) {
        return new sb_drive_list(properties);
    };

    /**
     * Encodes the specified sb_drive_list message. Does not implicitly {@link sb_drive_list.verify|verify} messages.
     * @function encode
     * @memberof sb_drive_list
     * @static
     * @param {Isb_drive_list} message sb_drive_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_drive_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.sbDrive != null && message.sbDrive.length)
            for (let i = 0; i < message.sbDrive.length; ++i)
                $root.sb_drive_info.encode(message.sbDrive[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified sb_drive_list message, length delimited. Does not implicitly {@link sb_drive_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof sb_drive_list
     * @static
     * @param {Isb_drive_list} message sb_drive_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_drive_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a sb_drive_list message from the specified reader or buffer.
     * @function decode
     * @memberof sb_drive_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {sb_drive_list} sb_drive_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_drive_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sb_drive_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.sbDrive && message.sbDrive.length))
                        message.sbDrive = [];
                    message.sbDrive.push($root.sb_drive_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a sb_drive_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof sb_drive_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {sb_drive_list} sb_drive_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_drive_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a sb_drive_list message.
     * @function verify
     * @memberof sb_drive_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    sb_drive_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.sbDrive != null && message.hasOwnProperty("sbDrive")) {
            if (!Array.isArray(message.sbDrive))
                return "sbDrive: array expected";
            for (let i = 0; i < message.sbDrive.length; ++i) {
                let error = $root.sb_drive_info.verify(message.sbDrive[i]);
                if (error)
                    return "sbDrive." + error;
            }
        }
        return null;
    };

    /**
     * Creates a sb_drive_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof sb_drive_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {sb_drive_list} sb_drive_list
     */
    sb_drive_list.fromObject = function fromObject(object) {
        if (object instanceof $root.sb_drive_list)
            return object;
        let message = new $root.sb_drive_list();
        if (object.sbDrive) {
            if (!Array.isArray(object.sbDrive))
                throw TypeError(".sb_drive_list.sbDrive: array expected");
            message.sbDrive = [];
            for (let i = 0; i < object.sbDrive.length; ++i) {
                if (typeof object.sbDrive[i] !== "object")
                    throw TypeError(".sb_drive_list.sbDrive: object expected");
                message.sbDrive[i] = $root.sb_drive_info.fromObject(object.sbDrive[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a sb_drive_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof sb_drive_list
     * @static
     * @param {sb_drive_list} message sb_drive_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    sb_drive_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.sbDrive = [];
        if (message.sbDrive && message.sbDrive.length) {
            object.sbDrive = [];
            for (let j = 0; j < message.sbDrive.length; ++j)
                object.sbDrive[j] = $root.sb_drive_info.toObject(message.sbDrive[j], options);
        }
        return object;
    };

    /**
     * Converts this sb_drive_list to JSON.
     * @function toJSON
     * @memberof sb_drive_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    sb_drive_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for sb_drive_list
     * @function getTypeUrl
     * @memberof sb_drive_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    sb_drive_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/sb_drive_list";
    };

    return sb_drive_list;
})();

export const sb_drive_info = $root.sb_drive_info = (() => {

    /**
     * Properties of a sb_drive_info.
     * @exports Isb_drive_info
     * @interface Isb_drive_info
     * @property {string|null} [name] sb_drive_info name
     * @property {Uint8Array|null} [config] sb_drive_info config
     */

    /**
     * Constructs a new sb_drive_info.
     * @exports sb_drive_info
     * @classdesc Represents a sb_drive_info.
     * @implements Isb_drive_info
     * @constructor
     * @param {Isb_drive_info=} [properties] Properties to set
     */
    function sb_drive_info(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * sb_drive_info name.
     * @member {string} name
     * @memberof sb_drive_info
     * @instance
     */
    sb_drive_info.prototype.name = "";

    /**
     * sb_drive_info config.
     * @member {Uint8Array} config
     * @memberof sb_drive_info
     * @instance
     */
    sb_drive_info.prototype.config = $util.newBuffer([]);

    /**
     * Creates a new sb_drive_info instance using the specified properties.
     * @function create
     * @memberof sb_drive_info
     * @static
     * @param {Isb_drive_info=} [properties] Properties to set
     * @returns {sb_drive_info} sb_drive_info instance
     */
    sb_drive_info.create = function create(properties) {
        return new sb_drive_info(properties);
    };

    /**
     * Encodes the specified sb_drive_info message. Does not implicitly {@link sb_drive_info.verify|verify} messages.
     * @function encode
     * @memberof sb_drive_info
     * @static
     * @param {Isb_drive_info} message sb_drive_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_drive_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.config != null && Object.hasOwnProperty.call(message, "config"))
            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.config);
        return writer;
    };

    /**
     * Encodes the specified sb_drive_info message, length delimited. Does not implicitly {@link sb_drive_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof sb_drive_info
     * @static
     * @param {Isb_drive_info} message sb_drive_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    sb_drive_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a sb_drive_info message from the specified reader or buffer.
     * @function decode
     * @memberof sb_drive_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {sb_drive_info} sb_drive_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_drive_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sb_drive_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.config = reader.bytes();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a sb_drive_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof sb_drive_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {sb_drive_info} sb_drive_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    sb_drive_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a sb_drive_info message.
     * @function verify
     * @memberof sb_drive_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    sb_drive_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.config != null && message.hasOwnProperty("config"))
            if (!(message.config && typeof message.config.length === "number" || $util.isString(message.config)))
                return "config: buffer expected";
        return null;
    };

    /**
     * Creates a sb_drive_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof sb_drive_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {sb_drive_info} sb_drive_info
     */
    sb_drive_info.fromObject = function fromObject(object) {
        if (object instanceof $root.sb_drive_info)
            return object;
        let message = new $root.sb_drive_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.config != null)
            if (typeof object.config === "string")
                $util.base64.decode(object.config, message.config = $util.newBuffer($util.base64.length(object.config)), 0);
            else if (object.config.length >= 0)
                message.config = object.config;
        return message;
    };

    /**
     * Creates a plain object from a sb_drive_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof sb_drive_info
     * @static
     * @param {sb_drive_info} message sb_drive_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    sb_drive_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            if (options.bytes === String)
                object.config = "";
            else {
                object.config = [];
                if (options.bytes !== Array)
                    object.config = $util.newBuffer(object.config);
            }
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.config != null && message.hasOwnProperty("config"))
            object.config = options.bytes === String ? $util.base64.encode(message.config, 0, message.config.length) : options.bytes === Array ? Array.prototype.slice.call(message.config) : message.config;
        return object;
    };

    /**
     * Converts this sb_drive_info to JSON.
     * @function toJSON
     * @memberof sb_drive_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    sb_drive_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for sb_drive_info
     * @function getTypeUrl
     * @memberof sb_drive_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    sb_drive_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/sb_drive_info";
    };

    return sb_drive_info;
})();

export const tx_list = $root.tx_list = (() => {

    /**
     * Properties of a tx_list.
     * @exports Itx_list
     * @interface Itx_list
     * @property {Array.<Itx_info>|null} [tx] tx_list tx
     */

    /**
     * Constructs a new tx_list.
     * @exports tx_list
     * @classdesc Represents a tx_list.
     * @implements Itx_list
     * @constructor
     * @param {Itx_list=} [properties] Properties to set
     */
    function tx_list(properties) {
        this.tx = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_list tx.
     * @member {Array.<Itx_info>} tx
     * @memberof tx_list
     * @instance
     */
    tx_list.prototype.tx = $util.emptyArray;

    /**
     * Creates a new tx_list instance using the specified properties.
     * @function create
     * @memberof tx_list
     * @static
     * @param {Itx_list=} [properties] Properties to set
     * @returns {tx_list} tx_list instance
     */
    tx_list.create = function create(properties) {
        return new tx_list(properties);
    };

    /**
     * Encodes the specified tx_list message. Does not implicitly {@link tx_list.verify|verify} messages.
     * @function encode
     * @memberof tx_list
     * @static
     * @param {Itx_list} message tx_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.tx != null && message.tx.length)
            for (let i = 0; i < message.tx.length; ++i)
                $root.tx_info.encode(message.tx[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified tx_list message, length delimited. Does not implicitly {@link tx_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_list
     * @static
     * @param {Itx_list} message tx_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_list message from the specified reader or buffer.
     * @function decode
     * @memberof tx_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_list} tx_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.tx && message.tx.length))
                        message.tx = [];
                    message.tx.push($root.tx_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_list} tx_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_list message.
     * @function verify
     * @memberof tx_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.tx != null && message.hasOwnProperty("tx")) {
            if (!Array.isArray(message.tx))
                return "tx: array expected";
            for (let i = 0; i < message.tx.length; ++i) {
                let error = $root.tx_info.verify(message.tx[i]);
                if (error)
                    return "tx." + error;
            }
        }
        return null;
    };

    /**
     * Creates a tx_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_list} tx_list
     */
    tx_list.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_list)
            return object;
        let message = new $root.tx_list();
        if (object.tx) {
            if (!Array.isArray(object.tx))
                throw TypeError(".tx_list.tx: array expected");
            message.tx = [];
            for (let i = 0; i < object.tx.length; ++i) {
                if (typeof object.tx[i] !== "object")
                    throw TypeError(".tx_list.tx: object expected");
                message.tx[i] = $root.tx_info.fromObject(object.tx[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a tx_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_list
     * @static
     * @param {tx_list} message tx_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.tx = [];
        if (message.tx && message.tx.length) {
            object.tx = [];
            for (let j = 0; j < message.tx.length; ++j)
                object.tx[j] = $root.tx_info.toObject(message.tx[j], options);
        }
        return object;
    };

    /**
     * Converts this tx_list to JSON.
     * @function toJSON
     * @memberof tx_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_list
     * @function getTypeUrl
     * @memberof tx_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_list";
    };

    return tx_list;
})();

export const tx_host = $root.tx_host = (() => {

    /**
     * Properties of a tx_host.
     * @exports Itx_host
     * @interface Itx_host
     * @property {Array.<string>|null} [host] tx_host host
     */

    /**
     * Constructs a new tx_host.
     * @exports tx_host
     * @classdesc Represents a tx_host.
     * @implements Itx_host
     * @constructor
     * @param {Itx_host=} [properties] Properties to set
     */
    function tx_host(properties) {
        this.host = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_host host.
     * @member {Array.<string>} host
     * @memberof tx_host
     * @instance
     */
    tx_host.prototype.host = $util.emptyArray;

    /**
     * Creates a new tx_host instance using the specified properties.
     * @function create
     * @memberof tx_host
     * @static
     * @param {Itx_host=} [properties] Properties to set
     * @returns {tx_host} tx_host instance
     */
    tx_host.create = function create(properties) {
        return new tx_host(properties);
    };

    /**
     * Encodes the specified tx_host message. Does not implicitly {@link tx_host.verify|verify} messages.
     * @function encode
     * @memberof tx_host
     * @static
     * @param {Itx_host} message tx_host message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_host.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.host != null && message.host.length)
            for (let i = 0; i < message.host.length; ++i)
                writer.uint32(/* id 1, wireType 2 =*/10).string(message.host[i]);
        return writer;
    };

    /**
     * Encodes the specified tx_host message, length delimited. Does not implicitly {@link tx_host.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_host
     * @static
     * @param {Itx_host} message tx_host message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_host.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_host message from the specified reader or buffer.
     * @function decode
     * @memberof tx_host
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_host} tx_host
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_host.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_host();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.host && message.host.length))
                        message.host = [];
                    message.host.push(reader.string());
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_host message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_host
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_host} tx_host
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_host.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_host message.
     * @function verify
     * @memberof tx_host
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_host.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.host != null && message.hasOwnProperty("host")) {
            if (!Array.isArray(message.host))
                return "host: array expected";
            for (let i = 0; i < message.host.length; ++i)
                if (!$util.isString(message.host[i]))
                    return "host: string[] expected";
        }
        return null;
    };

    /**
     * Creates a tx_host message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_host
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_host} tx_host
     */
    tx_host.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_host)
            return object;
        let message = new $root.tx_host();
        if (object.host) {
            if (!Array.isArray(object.host))
                throw TypeError(".tx_host.host: array expected");
            message.host = [];
            for (let i = 0; i < object.host.length; ++i)
                message.host[i] = String(object.host[i]);
        }
        return message;
    };

    /**
     * Creates a plain object from a tx_host message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_host
     * @static
     * @param {tx_host} message tx_host
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_host.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.host = [];
        if (message.host && message.host.length) {
            object.host = [];
            for (let j = 0; j < message.host.length; ++j)
                object.host[j] = message.host[j];
        }
        return object;
    };

    /**
     * Converts this tx_host to JSON.
     * @function toJSON
     * @memberof tx_host
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_host.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_host
     * @function getTypeUrl
     * @memberof tx_host
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_host.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_host";
    };

    return tx_host;
})();

export const tx_info = $root.tx_info = (() => {

    /**
     * Properties of a tx_info.
     * @exports Itx_info
     * @interface Itx_info
     * @property {string|null} [name] tx_info name
     * @property {string|null} [drive] tx_info drive
     * @property {boolean|null} [serial] tx_info serial
     * @property {string|null} [host] tx_info host
     * @property {number|null} [status] tx_info status
     * @property {string|null} [description] tx_info description
     * @property {boolean|null} [enable] tx_info enable
     * @property {Array.<Itx_device_info>|null} [device] tx_info device
     */

    /**
     * Constructs a new tx_info.
     * @exports tx_info
     * @classdesc Represents a tx_info.
     * @implements Itx_info
     * @constructor
     * @param {Itx_info=} [properties] Properties to set
     */
    function tx_info(properties) {
        this.device = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_info name.
     * @member {string} name
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.name = "";

    /**
     * tx_info drive.
     * @member {string} drive
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.drive = "";

    /**
     * tx_info serial.
     * @member {boolean} serial
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.serial = false;

    /**
     * tx_info host.
     * @member {string} host
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.host = "";

    /**
     * tx_info status.
     * @member {number} status
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.status = 0;

    /**
     * tx_info description.
     * @member {string} description
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.description = "";

    /**
     * tx_info enable.
     * @member {boolean} enable
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.enable = false;

    /**
     * tx_info device.
     * @member {Array.<Itx_device_info>} device
     * @memberof tx_info
     * @instance
     */
    tx_info.prototype.device = $util.emptyArray;

    /**
     * Creates a new tx_info instance using the specified properties.
     * @function create
     * @memberof tx_info
     * @static
     * @param {Itx_info=} [properties] Properties to set
     * @returns {tx_info} tx_info instance
     */
    tx_info.create = function create(properties) {
        return new tx_info(properties);
    };

    /**
     * Encodes the specified tx_info message. Does not implicitly {@link tx_info.verify|verify} messages.
     * @function encode
     * @memberof tx_info
     * @static
     * @param {Itx_info} message tx_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.drive != null && Object.hasOwnProperty.call(message, "drive"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.drive);
        if (message.serial != null && Object.hasOwnProperty.call(message, "serial"))
            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.serial);
        if (message.host != null && Object.hasOwnProperty.call(message, "host"))
            writer.uint32(/* id 4, wireType 2 =*/34).string(message.host);
        if (message.status != null && Object.hasOwnProperty.call(message, "status"))
            writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.status);
        if (message.description != null && Object.hasOwnProperty.call(message, "description"))
            writer.uint32(/* id 6, wireType 2 =*/50).string(message.description);
        if (message.enable != null && Object.hasOwnProperty.call(message, "enable"))
            writer.uint32(/* id 7, wireType 0 =*/56).bool(message.enable);
        if (message.device != null && message.device.length)
            for (let i = 0; i < message.device.length; ++i)
                $root.tx_device_info.encode(message.device[i], writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified tx_info message, length delimited. Does not implicitly {@link tx_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_info
     * @static
     * @param {Itx_info} message tx_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_info message from the specified reader or buffer.
     * @function decode
     * @memberof tx_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_info} tx_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.drive = reader.string();
                    break;
                }
            case 3: {
                    message.serial = reader.bool();
                    break;
                }
            case 4: {
                    message.host = reader.string();
                    break;
                }
            case 5: {
                    message.status = reader.uint32();
                    break;
                }
            case 6: {
                    message.description = reader.string();
                    break;
                }
            case 7: {
                    message.enable = reader.bool();
                    break;
                }
            case 8: {
                    if (!(message.device && message.device.length))
                        message.device = [];
                    message.device.push($root.tx_device_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_info} tx_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_info message.
     * @function verify
     * @memberof tx_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.drive != null && message.hasOwnProperty("drive"))
            if (!$util.isString(message.drive))
                return "drive: string expected";
        if (message.serial != null && message.hasOwnProperty("serial"))
            if (typeof message.serial !== "boolean")
                return "serial: boolean expected";
        if (message.host != null && message.hasOwnProperty("host"))
            if (!$util.isString(message.host))
                return "host: string expected";
        if (message.status != null && message.hasOwnProperty("status"))
            if (!$util.isInteger(message.status))
                return "status: integer expected";
        if (message.description != null && message.hasOwnProperty("description"))
            if (!$util.isString(message.description))
                return "description: string expected";
        if (message.enable != null && message.hasOwnProperty("enable"))
            if (typeof message.enable !== "boolean")
                return "enable: boolean expected";
        if (message.device != null && message.hasOwnProperty("device")) {
            if (!Array.isArray(message.device))
                return "device: array expected";
            for (let i = 0; i < message.device.length; ++i) {
                let error = $root.tx_device_info.verify(message.device[i]);
                if (error)
                    return "device." + error;
            }
        }
        return null;
    };

    /**
     * Creates a tx_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_info} tx_info
     */
    tx_info.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_info)
            return object;
        let message = new $root.tx_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.drive != null)
            message.drive = String(object.drive);
        if (object.serial != null)
            message.serial = Boolean(object.serial);
        if (object.host != null)
            message.host = String(object.host);
        if (object.status != null)
            message.status = object.status >>> 0;
        if (object.description != null)
            message.description = String(object.description);
        if (object.enable != null)
            message.enable = Boolean(object.enable);
        if (object.device) {
            if (!Array.isArray(object.device))
                throw TypeError(".tx_info.device: array expected");
            message.device = [];
            for (let i = 0; i < object.device.length; ++i) {
                if (typeof object.device[i] !== "object")
                    throw TypeError(".tx_info.device: object expected");
                message.device[i] = $root.tx_device_info.fromObject(object.device[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a tx_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_info
     * @static
     * @param {tx_info} message tx_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.device = [];
        if (options.defaults) {
            object.name = "";
            object.drive = "";
            object.serial = false;
            object.host = "";
            object.status = 0;
            object.description = "";
            object.enable = false;
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.drive != null && message.hasOwnProperty("drive"))
            object.drive = message.drive;
        if (message.serial != null && message.hasOwnProperty("serial"))
            object.serial = message.serial;
        if (message.host != null && message.hasOwnProperty("host"))
            object.host = message.host;
        if (message.status != null && message.hasOwnProperty("status"))
            object.status = message.status;
        if (message.description != null && message.hasOwnProperty("description"))
            object.description = message.description;
        if (message.enable != null && message.hasOwnProperty("enable"))
            object.enable = message.enable;
        if (message.device && message.device.length) {
            object.device = [];
            for (let j = 0; j < message.device.length; ++j)
                object.device[j] = $root.tx_device_info.toObject(message.device[j], options);
        }
        return object;
    };

    /**
     * Converts this tx_info to JSON.
     * @function toJSON
     * @memberof tx_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_info
     * @function getTypeUrl
     * @memberof tx_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_info";
    };

    return tx_info;
})();

export const tx_add = $root.tx_add = (() => {

    /**
     * Properties of a tx_add.
     * @exports Itx_add
     * @interface Itx_add
     * @property {string|null} [name] tx_add name
     * @property {string|null} [drive] tx_add drive
     * @property {boolean|null} [serial] tx_add serial
     * @property {string|null} [description] tx_add description
     * @property {Uint8Array|null} [config] tx_add config
     */

    /**
     * Constructs a new tx_add.
     * @exports tx_add
     * @classdesc Represents a tx_add.
     * @implements Itx_add
     * @constructor
     * @param {Itx_add=} [properties] Properties to set
     */
    function tx_add(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_add name.
     * @member {string} name
     * @memberof tx_add
     * @instance
     */
    tx_add.prototype.name = "";

    /**
     * tx_add drive.
     * @member {string} drive
     * @memberof tx_add
     * @instance
     */
    tx_add.prototype.drive = "";

    /**
     * tx_add serial.
     * @member {boolean} serial
     * @memberof tx_add
     * @instance
     */
    tx_add.prototype.serial = false;

    /**
     * tx_add description.
     * @member {string} description
     * @memberof tx_add
     * @instance
     */
    tx_add.prototype.description = "";

    /**
     * tx_add config.
     * @member {Uint8Array} config
     * @memberof tx_add
     * @instance
     */
    tx_add.prototype.config = $util.newBuffer([]);

    /**
     * Creates a new tx_add instance using the specified properties.
     * @function create
     * @memberof tx_add
     * @static
     * @param {Itx_add=} [properties] Properties to set
     * @returns {tx_add} tx_add instance
     */
    tx_add.create = function create(properties) {
        return new tx_add(properties);
    };

    /**
     * Encodes the specified tx_add message. Does not implicitly {@link tx_add.verify|verify} messages.
     * @function encode
     * @memberof tx_add
     * @static
     * @param {Itx_add} message tx_add message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_add.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.drive != null && Object.hasOwnProperty.call(message, "drive"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.drive);
        if (message.serial != null && Object.hasOwnProperty.call(message, "serial"))
            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.serial);
        if (message.description != null && Object.hasOwnProperty.call(message, "description"))
            writer.uint32(/* id 4, wireType 2 =*/34).string(message.description);
        if (message.config != null && Object.hasOwnProperty.call(message, "config"))
            writer.uint32(/* id 5, wireType 2 =*/42).bytes(message.config);
        return writer;
    };

    /**
     * Encodes the specified tx_add message, length delimited. Does not implicitly {@link tx_add.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_add
     * @static
     * @param {Itx_add} message tx_add message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_add.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_add message from the specified reader or buffer.
     * @function decode
     * @memberof tx_add
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_add} tx_add
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_add.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_add();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.drive = reader.string();
                    break;
                }
            case 3: {
                    message.serial = reader.bool();
                    break;
                }
            case 4: {
                    message.description = reader.string();
                    break;
                }
            case 5: {
                    message.config = reader.bytes();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_add message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_add
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_add} tx_add
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_add.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_add message.
     * @function verify
     * @memberof tx_add
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_add.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.drive != null && message.hasOwnProperty("drive"))
            if (!$util.isString(message.drive))
                return "drive: string expected";
        if (message.serial != null && message.hasOwnProperty("serial"))
            if (typeof message.serial !== "boolean")
                return "serial: boolean expected";
        if (message.description != null && message.hasOwnProperty("description"))
            if (!$util.isString(message.description))
                return "description: string expected";
        if (message.config != null && message.hasOwnProperty("config"))
            if (!(message.config && typeof message.config.length === "number" || $util.isString(message.config)))
                return "config: buffer expected";
        return null;
    };

    /**
     * Creates a tx_add message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_add
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_add} tx_add
     */
    tx_add.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_add)
            return object;
        let message = new $root.tx_add();
        if (object.name != null)
            message.name = String(object.name);
        if (object.drive != null)
            message.drive = String(object.drive);
        if (object.serial != null)
            message.serial = Boolean(object.serial);
        if (object.description != null)
            message.description = String(object.description);
        if (object.config != null)
            if (typeof object.config === "string")
                $util.base64.decode(object.config, message.config = $util.newBuffer($util.base64.length(object.config)), 0);
            else if (object.config.length >= 0)
                message.config = object.config;
        return message;
    };

    /**
     * Creates a plain object from a tx_add message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_add
     * @static
     * @param {tx_add} message tx_add
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_add.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.drive = "";
            object.serial = false;
            object.description = "";
            if (options.bytes === String)
                object.config = "";
            else {
                object.config = [];
                if (options.bytes !== Array)
                    object.config = $util.newBuffer(object.config);
            }
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.drive != null && message.hasOwnProperty("drive"))
            object.drive = message.drive;
        if (message.serial != null && message.hasOwnProperty("serial"))
            object.serial = message.serial;
        if (message.description != null && message.hasOwnProperty("description"))
            object.description = message.description;
        if (message.config != null && message.hasOwnProperty("config"))
            object.config = options.bytes === String ? $util.base64.encode(message.config, 0, message.config.length) : options.bytes === Array ? Array.prototype.slice.call(message.config) : message.config;
        return object;
    };

    /**
     * Converts this tx_add to JSON.
     * @function toJSON
     * @memberof tx_add
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_add.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_add
     * @function getTypeUrl
     * @memberof tx_add
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_add.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_add";
    };

    return tx_add;
})();

export const tx_add_device = $root.tx_add_device = (() => {

    /**
     * Properties of a tx_add_device.
     * @exports Itx_add_device
     * @interface Itx_add_device
     * @property {string|null} [name] tx_add_device name
     * @property {Array.<Itx_device_info>|null} [device] tx_add_device device
     */

    /**
     * Constructs a new tx_add_device.
     * @exports tx_add_device
     * @classdesc Represents a tx_add_device.
     * @implements Itx_add_device
     * @constructor
     * @param {Itx_add_device=} [properties] Properties to set
     */
    function tx_add_device(properties) {
        this.device = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_add_device name.
     * @member {string} name
     * @memberof tx_add_device
     * @instance
     */
    tx_add_device.prototype.name = "";

    /**
     * tx_add_device device.
     * @member {Array.<Itx_device_info>} device
     * @memberof tx_add_device
     * @instance
     */
    tx_add_device.prototype.device = $util.emptyArray;

    /**
     * Creates a new tx_add_device instance using the specified properties.
     * @function create
     * @memberof tx_add_device
     * @static
     * @param {Itx_add_device=} [properties] Properties to set
     * @returns {tx_add_device} tx_add_device instance
     */
    tx_add_device.create = function create(properties) {
        return new tx_add_device(properties);
    };

    /**
     * Encodes the specified tx_add_device message. Does not implicitly {@link tx_add_device.verify|verify} messages.
     * @function encode
     * @memberof tx_add_device
     * @static
     * @param {Itx_add_device} message tx_add_device message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_add_device.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.device != null && message.device.length)
            for (let i = 0; i < message.device.length; ++i)
                $root.tx_device_info.encode(message.device[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified tx_add_device message, length delimited. Does not implicitly {@link tx_add_device.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_add_device
     * @static
     * @param {Itx_add_device} message tx_add_device message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_add_device.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_add_device message from the specified reader or buffer.
     * @function decode
     * @memberof tx_add_device
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_add_device} tx_add_device
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_add_device.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_add_device();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    if (!(message.device && message.device.length))
                        message.device = [];
                    message.device.push($root.tx_device_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_add_device message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_add_device
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_add_device} tx_add_device
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_add_device.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_add_device message.
     * @function verify
     * @memberof tx_add_device
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_add_device.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.device != null && message.hasOwnProperty("device")) {
            if (!Array.isArray(message.device))
                return "device: array expected";
            for (let i = 0; i < message.device.length; ++i) {
                let error = $root.tx_device_info.verify(message.device[i]);
                if (error)
                    return "device." + error;
            }
        }
        return null;
    };

    /**
     * Creates a tx_add_device message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_add_device
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_add_device} tx_add_device
     */
    tx_add_device.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_add_device)
            return object;
        let message = new $root.tx_add_device();
        if (object.name != null)
            message.name = String(object.name);
        if (object.device) {
            if (!Array.isArray(object.device))
                throw TypeError(".tx_add_device.device: array expected");
            message.device = [];
            for (let i = 0; i < object.device.length; ++i) {
                if (typeof object.device[i] !== "object")
                    throw TypeError(".tx_add_device.device: object expected");
                message.device[i] = $root.tx_device_info.fromObject(object.device[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a tx_add_device message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_add_device
     * @static
     * @param {tx_add_device} message tx_add_device
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_add_device.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.device = [];
        if (options.defaults)
            object.name = "";
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.device && message.device.length) {
            object.device = [];
            for (let j = 0; j < message.device.length; ++j)
                object.device[j] = $root.tx_device_info.toObject(message.device[j], options);
        }
        return object;
    };

    /**
     * Converts this tx_add_device to JSON.
     * @function toJSON
     * @memberof tx_add_device
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_add_device.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_add_device
     * @function getTypeUrl
     * @memberof tx_add_device
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_add_device.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_add_device";
    };

    return tx_add_device;
})();

export const tx_drive_list = $root.tx_drive_list = (() => {

    /**
     * Properties of a tx_drive_list.
     * @exports Itx_drive_list
     * @interface Itx_drive_list
     * @property {Array.<Itx_drive_info>|null} [txDrive] tx_drive_list txDrive
     */

    /**
     * Constructs a new tx_drive_list.
     * @exports tx_drive_list
     * @classdesc Represents a tx_drive_list.
     * @implements Itx_drive_list
     * @constructor
     * @param {Itx_drive_list=} [properties] Properties to set
     */
    function tx_drive_list(properties) {
        this.txDrive = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_drive_list txDrive.
     * @member {Array.<Itx_drive_info>} txDrive
     * @memberof tx_drive_list
     * @instance
     */
    tx_drive_list.prototype.txDrive = $util.emptyArray;

    /**
     * Creates a new tx_drive_list instance using the specified properties.
     * @function create
     * @memberof tx_drive_list
     * @static
     * @param {Itx_drive_list=} [properties] Properties to set
     * @returns {tx_drive_list} tx_drive_list instance
     */
    tx_drive_list.create = function create(properties) {
        return new tx_drive_list(properties);
    };

    /**
     * Encodes the specified tx_drive_list message. Does not implicitly {@link tx_drive_list.verify|verify} messages.
     * @function encode
     * @memberof tx_drive_list
     * @static
     * @param {Itx_drive_list} message tx_drive_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_drive_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.txDrive != null && message.txDrive.length)
            for (let i = 0; i < message.txDrive.length; ++i)
                $root.tx_drive_info.encode(message.txDrive[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified tx_drive_list message, length delimited. Does not implicitly {@link tx_drive_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_drive_list
     * @static
     * @param {Itx_drive_list} message tx_drive_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_drive_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_drive_list message from the specified reader or buffer.
     * @function decode
     * @memberof tx_drive_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_drive_list} tx_drive_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_drive_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_drive_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.txDrive && message.txDrive.length))
                        message.txDrive = [];
                    message.txDrive.push($root.tx_drive_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_drive_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_drive_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_drive_list} tx_drive_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_drive_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_drive_list message.
     * @function verify
     * @memberof tx_drive_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_drive_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.txDrive != null && message.hasOwnProperty("txDrive")) {
            if (!Array.isArray(message.txDrive))
                return "txDrive: array expected";
            for (let i = 0; i < message.txDrive.length; ++i) {
                let error = $root.tx_drive_info.verify(message.txDrive[i]);
                if (error)
                    return "txDrive." + error;
            }
        }
        return null;
    };

    /**
     * Creates a tx_drive_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_drive_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_drive_list} tx_drive_list
     */
    tx_drive_list.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_drive_list)
            return object;
        let message = new $root.tx_drive_list();
        if (object.txDrive) {
            if (!Array.isArray(object.txDrive))
                throw TypeError(".tx_drive_list.txDrive: array expected");
            message.txDrive = [];
            for (let i = 0; i < object.txDrive.length; ++i) {
                if (typeof object.txDrive[i] !== "object")
                    throw TypeError(".tx_drive_list.txDrive: object expected");
                message.txDrive[i] = $root.tx_drive_info.fromObject(object.txDrive[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a tx_drive_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_drive_list
     * @static
     * @param {tx_drive_list} message tx_drive_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_drive_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.txDrive = [];
        if (message.txDrive && message.txDrive.length) {
            object.txDrive = [];
            for (let j = 0; j < message.txDrive.length; ++j)
                object.txDrive[j] = $root.tx_drive_info.toObject(message.txDrive[j], options);
        }
        return object;
    };

    /**
     * Converts this tx_drive_list to JSON.
     * @function toJSON
     * @memberof tx_drive_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_drive_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_drive_list
     * @function getTypeUrl
     * @memberof tx_drive_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_drive_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_drive_list";
    };

    return tx_drive_list;
})();

export const tx_drive_info = $root.tx_drive_info = (() => {

    /**
     * Properties of a tx_drive_info.
     * @exports Itx_drive_info
     * @interface Itx_drive_info
     * @property {string|null} [name] tx_drive_info name
     * @property {boolean|null} [serial] tx_drive_info serial
     * @property {Uint8Array|null} [config] tx_drive_info config
     */

    /**
     * Constructs a new tx_drive_info.
     * @exports tx_drive_info
     * @classdesc Represents a tx_drive_info.
     * @implements Itx_drive_info
     * @constructor
     * @param {Itx_drive_info=} [properties] Properties to set
     */
    function tx_drive_info(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_drive_info name.
     * @member {string} name
     * @memberof tx_drive_info
     * @instance
     */
    tx_drive_info.prototype.name = "";

    /**
     * tx_drive_info serial.
     * @member {boolean} serial
     * @memberof tx_drive_info
     * @instance
     */
    tx_drive_info.prototype.serial = false;

    /**
     * tx_drive_info config.
     * @member {Uint8Array} config
     * @memberof tx_drive_info
     * @instance
     */
    tx_drive_info.prototype.config = $util.newBuffer([]);

    /**
     * Creates a new tx_drive_info instance using the specified properties.
     * @function create
     * @memberof tx_drive_info
     * @static
     * @param {Itx_drive_info=} [properties] Properties to set
     * @returns {tx_drive_info} tx_drive_info instance
     */
    tx_drive_info.create = function create(properties) {
        return new tx_drive_info(properties);
    };

    /**
     * Encodes the specified tx_drive_info message. Does not implicitly {@link tx_drive_info.verify|verify} messages.
     * @function encode
     * @memberof tx_drive_info
     * @static
     * @param {Itx_drive_info} message tx_drive_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_drive_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.serial != null && Object.hasOwnProperty.call(message, "serial"))
            writer.uint32(/* id 2, wireType 0 =*/16).bool(message.serial);
        if (message.config != null && Object.hasOwnProperty.call(message, "config"))
            writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.config);
        return writer;
    };

    /**
     * Encodes the specified tx_drive_info message, length delimited. Does not implicitly {@link tx_drive_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_drive_info
     * @static
     * @param {Itx_drive_info} message tx_drive_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_drive_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_drive_info message from the specified reader or buffer.
     * @function decode
     * @memberof tx_drive_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_drive_info} tx_drive_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_drive_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_drive_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.serial = reader.bool();
                    break;
                }
            case 3: {
                    message.config = reader.bytes();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_drive_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_drive_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_drive_info} tx_drive_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_drive_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_drive_info message.
     * @function verify
     * @memberof tx_drive_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_drive_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.serial != null && message.hasOwnProperty("serial"))
            if (typeof message.serial !== "boolean")
                return "serial: boolean expected";
        if (message.config != null && message.hasOwnProperty("config"))
            if (!(message.config && typeof message.config.length === "number" || $util.isString(message.config)))
                return "config: buffer expected";
        return null;
    };

    /**
     * Creates a tx_drive_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_drive_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_drive_info} tx_drive_info
     */
    tx_drive_info.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_drive_info)
            return object;
        let message = new $root.tx_drive_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.serial != null)
            message.serial = Boolean(object.serial);
        if (object.config != null)
            if (typeof object.config === "string")
                $util.base64.decode(object.config, message.config = $util.newBuffer($util.base64.length(object.config)), 0);
            else if (object.config.length >= 0)
                message.config = object.config;
        return message;
    };

    /**
     * Creates a plain object from a tx_drive_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_drive_info
     * @static
     * @param {tx_drive_info} message tx_drive_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_drive_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.serial = false;
            if (options.bytes === String)
                object.config = "";
            else {
                object.config = [];
                if (options.bytes !== Array)
                    object.config = $util.newBuffer(object.config);
            }
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.serial != null && message.hasOwnProperty("serial"))
            object.serial = message.serial;
        if (message.config != null && message.hasOwnProperty("config"))
            object.config = options.bytes === String ? $util.base64.encode(message.config, 0, message.config.length) : options.bytes === Array ? Array.prototype.slice.call(message.config) : message.config;
        return object;
    };

    /**
     * Converts this tx_drive_info to JSON.
     * @function toJSON
     * @memberof tx_drive_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_drive_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_drive_info
     * @function getTypeUrl
     * @memberof tx_drive_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_drive_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_drive_info";
    };

    return tx_drive_info;
})();

export const tx_drive_config_modbusTCP = $root.tx_drive_config_modbusTCP = (() => {

    /**
     * Properties of a tx_drive_config_modbusTCP.
     * @exports Itx_drive_config_modbusTCP
     * @interface Itx_drive_config_modbusTCP
     * @property {string|null} [host] tx_drive_config_modbusTCP host
     * @property {string|null} [port] tx_drive_config_modbusTCP port
     */

    /**
     * Constructs a new tx_drive_config_modbusTCP.
     * @exports tx_drive_config_modbusTCP
     * @classdesc Represents a tx_drive_config_modbusTCP.
     * @implements Itx_drive_config_modbusTCP
     * @constructor
     * @param {Itx_drive_config_modbusTCP=} [properties] Properties to set
     */
    function tx_drive_config_modbusTCP(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_drive_config_modbusTCP host.
     * @member {string} host
     * @memberof tx_drive_config_modbusTCP
     * @instance
     */
    tx_drive_config_modbusTCP.prototype.host = "";

    /**
     * tx_drive_config_modbusTCP port.
     * @member {string} port
     * @memberof tx_drive_config_modbusTCP
     * @instance
     */
    tx_drive_config_modbusTCP.prototype.port = "";

    /**
     * Creates a new tx_drive_config_modbusTCP instance using the specified properties.
     * @function create
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {Itx_drive_config_modbusTCP=} [properties] Properties to set
     * @returns {tx_drive_config_modbusTCP} tx_drive_config_modbusTCP instance
     */
    tx_drive_config_modbusTCP.create = function create(properties) {
        return new tx_drive_config_modbusTCP(properties);
    };

    /**
     * Encodes the specified tx_drive_config_modbusTCP message. Does not implicitly {@link tx_drive_config_modbusTCP.verify|verify} messages.
     * @function encode
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {Itx_drive_config_modbusTCP} message tx_drive_config_modbusTCP message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_drive_config_modbusTCP.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.host != null && Object.hasOwnProperty.call(message, "host"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.host);
        if (message.port != null && Object.hasOwnProperty.call(message, "port"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.port);
        return writer;
    };

    /**
     * Encodes the specified tx_drive_config_modbusTCP message, length delimited. Does not implicitly {@link tx_drive_config_modbusTCP.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {Itx_drive_config_modbusTCP} message tx_drive_config_modbusTCP message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_drive_config_modbusTCP.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_drive_config_modbusTCP message from the specified reader or buffer.
     * @function decode
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_drive_config_modbusTCP} tx_drive_config_modbusTCP
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_drive_config_modbusTCP.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_drive_config_modbusTCP();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.host = reader.string();
                    break;
                }
            case 2: {
                    message.port = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_drive_config_modbusTCP message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_drive_config_modbusTCP} tx_drive_config_modbusTCP
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_drive_config_modbusTCP.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_drive_config_modbusTCP message.
     * @function verify
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_drive_config_modbusTCP.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.host != null && message.hasOwnProperty("host"))
            if (!$util.isString(message.host))
                return "host: string expected";
        if (message.port != null && message.hasOwnProperty("port"))
            if (!$util.isString(message.port))
                return "port: string expected";
        return null;
    };

    /**
     * Creates a tx_drive_config_modbusTCP message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_drive_config_modbusTCP} tx_drive_config_modbusTCP
     */
    tx_drive_config_modbusTCP.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_drive_config_modbusTCP)
            return object;
        let message = new $root.tx_drive_config_modbusTCP();
        if (object.host != null)
            message.host = String(object.host);
        if (object.port != null)
            message.port = String(object.port);
        return message;
    };

    /**
     * Creates a plain object from a tx_drive_config_modbusTCP message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {tx_drive_config_modbusTCP} message tx_drive_config_modbusTCP
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_drive_config_modbusTCP.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.host = "";
            object.port = "";
        }
        if (message.host != null && message.hasOwnProperty("host"))
            object.host = message.host;
        if (message.port != null && message.hasOwnProperty("port"))
            object.port = message.port;
        return object;
    };

    /**
     * Converts this tx_drive_config_modbusTCP to JSON.
     * @function toJSON
     * @memberof tx_drive_config_modbusTCP
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_drive_config_modbusTCP.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_drive_config_modbusTCP
     * @function getTypeUrl
     * @memberof tx_drive_config_modbusTCP
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_drive_config_modbusTCP.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_drive_config_modbusTCP";
    };

    return tx_drive_config_modbusTCP;
})();

export const tx_device_info = $root.tx_device_info = (() => {

    /**
     * Properties of a tx_device_info.
     * @exports Itx_device_info
     * @interface Itx_device_info
     * @property {string|null} [name] tx_device_info name
     * @property {string|null} [template] tx_device_info template
     * @property {Array.<Im_properties>|null} [properties] tx_device_info properties
     */

    /**
     * Constructs a new tx_device_info.
     * @exports tx_device_info
     * @classdesc Represents a tx_device_info.
     * @implements Itx_device_info
     * @constructor
     * @param {Itx_device_info=} [properties] Properties to set
     */
    function tx_device_info(properties) {
        this.properties = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * tx_device_info name.
     * @member {string} name
     * @memberof tx_device_info
     * @instance
     */
    tx_device_info.prototype.name = "";

    /**
     * tx_device_info template.
     * @member {string} template
     * @memberof tx_device_info
     * @instance
     */
    tx_device_info.prototype.template = "";

    /**
     * tx_device_info properties.
     * @member {Array.<Im_properties>} properties
     * @memberof tx_device_info
     * @instance
     */
    tx_device_info.prototype.properties = $util.emptyArray;

    /**
     * Creates a new tx_device_info instance using the specified properties.
     * @function create
     * @memberof tx_device_info
     * @static
     * @param {Itx_device_info=} [properties] Properties to set
     * @returns {tx_device_info} tx_device_info instance
     */
    tx_device_info.create = function create(properties) {
        return new tx_device_info(properties);
    };

    /**
     * Encodes the specified tx_device_info message. Does not implicitly {@link tx_device_info.verify|verify} messages.
     * @function encode
     * @memberof tx_device_info
     * @static
     * @param {Itx_device_info} message tx_device_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_device_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.template != null && Object.hasOwnProperty.call(message, "template"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.template);
        if (message.properties != null && message.properties.length)
            for (let i = 0; i < message.properties.length; ++i)
                $root.m_properties.encode(message.properties[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified tx_device_info message, length delimited. Does not implicitly {@link tx_device_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof tx_device_info
     * @static
     * @param {Itx_device_info} message tx_device_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    tx_device_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a tx_device_info message from the specified reader or buffer.
     * @function decode
     * @memberof tx_device_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {tx_device_info} tx_device_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_device_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.tx_device_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.template = reader.string();
                    break;
                }
            case 3: {
                    if (!(message.properties && message.properties.length))
                        message.properties = [];
                    message.properties.push($root.m_properties.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a tx_device_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof tx_device_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {tx_device_info} tx_device_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    tx_device_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a tx_device_info message.
     * @function verify
     * @memberof tx_device_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    tx_device_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.template != null && message.hasOwnProperty("template"))
            if (!$util.isString(message.template))
                return "template: string expected";
        if (message.properties != null && message.hasOwnProperty("properties")) {
            if (!Array.isArray(message.properties))
                return "properties: array expected";
            for (let i = 0; i < message.properties.length; ++i) {
                let error = $root.m_properties.verify(message.properties[i]);
                if (error)
                    return "properties." + error;
            }
        }
        return null;
    };

    /**
     * Creates a tx_device_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof tx_device_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {tx_device_info} tx_device_info
     */
    tx_device_info.fromObject = function fromObject(object) {
        if (object instanceof $root.tx_device_info)
            return object;
        let message = new $root.tx_device_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.template != null)
            message.template = String(object.template);
        if (object.properties) {
            if (!Array.isArray(object.properties))
                throw TypeError(".tx_device_info.properties: array expected");
            message.properties = [];
            for (let i = 0; i < object.properties.length; ++i) {
                if (typeof object.properties[i] !== "object")
                    throw TypeError(".tx_device_info.properties: object expected");
                message.properties[i] = $root.m_properties.fromObject(object.properties[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a tx_device_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof tx_device_info
     * @static
     * @param {tx_device_info} message tx_device_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    tx_device_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.properties = [];
        if (options.defaults) {
            object.name = "";
            object.template = "";
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.template != null && message.hasOwnProperty("template"))
            object.template = message.template;
        if (message.properties && message.properties.length) {
            object.properties = [];
            for (let j = 0; j < message.properties.length; ++j)
                object.properties[j] = $root.m_properties.toObject(message.properties[j], options);
        }
        return object;
    };

    /**
     * Converts this tx_device_info to JSON.
     * @function toJSON
     * @memberof tx_device_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    tx_device_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for tx_device_info
     * @function getTypeUrl
     * @memberof tx_device_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    tx_device_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/tx_device_info";
    };

    return tx_device_info;
})();

export const mb_list = $root.mb_list = (() => {

    /**
     * Properties of a mb_list.
     * @exports Imb_list
     * @interface Imb_list
     * @property {Array.<Imb_info>|null} [mb] mb_list mb
     */

    /**
     * Constructs a new mb_list.
     * @exports mb_list
     * @classdesc Represents a mb_list.
     * @implements Imb_list
     * @constructor
     * @param {Imb_list=} [properties] Properties to set
     */
    function mb_list(properties) {
        this.mb = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * mb_list mb.
     * @member {Array.<Imb_info>} mb
     * @memberof mb_list
     * @instance
     */
    mb_list.prototype.mb = $util.emptyArray;

    /**
     * Creates a new mb_list instance using the specified properties.
     * @function create
     * @memberof mb_list
     * @static
     * @param {Imb_list=} [properties] Properties to set
     * @returns {mb_list} mb_list instance
     */
    mb_list.create = function create(properties) {
        return new mb_list(properties);
    };

    /**
     * Encodes the specified mb_list message. Does not implicitly {@link mb_list.verify|verify} messages.
     * @function encode
     * @memberof mb_list
     * @static
     * @param {Imb_list} message mb_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    mb_list.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.mb != null && message.mb.length)
            for (let i = 0; i < message.mb.length; ++i)
                $root.mb_info.encode(message.mb[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified mb_list message, length delimited. Does not implicitly {@link mb_list.verify|verify} messages.
     * @function encodeDelimited
     * @memberof mb_list
     * @static
     * @param {Imb_list} message mb_list message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    mb_list.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a mb_list message from the specified reader or buffer.
     * @function decode
     * @memberof mb_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {mb_list} mb_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    mb_list.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.mb_list();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    if (!(message.mb && message.mb.length))
                        message.mb = [];
                    message.mb.push($root.mb_info.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a mb_list message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof mb_list
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {mb_list} mb_list
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    mb_list.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a mb_list message.
     * @function verify
     * @memberof mb_list
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    mb_list.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.mb != null && message.hasOwnProperty("mb")) {
            if (!Array.isArray(message.mb))
                return "mb: array expected";
            for (let i = 0; i < message.mb.length; ++i) {
                let error = $root.mb_info.verify(message.mb[i]);
                if (error)
                    return "mb." + error;
            }
        }
        return null;
    };

    /**
     * Creates a mb_list message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof mb_list
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {mb_list} mb_list
     */
    mb_list.fromObject = function fromObject(object) {
        if (object instanceof $root.mb_list)
            return object;
        let message = new $root.mb_list();
        if (object.mb) {
            if (!Array.isArray(object.mb))
                throw TypeError(".mb_list.mb: array expected");
            message.mb = [];
            for (let i = 0; i < object.mb.length; ++i) {
                if (typeof object.mb[i] !== "object")
                    throw TypeError(".mb_list.mb: object expected");
                message.mb[i] = $root.mb_info.fromObject(object.mb[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a mb_list message. Also converts values to other types if specified.
     * @function toObject
     * @memberof mb_list
     * @static
     * @param {mb_list} message mb_list
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    mb_list.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.mb = [];
        if (message.mb && message.mb.length) {
            object.mb = [];
            for (let j = 0; j < message.mb.length; ++j)
                object.mb[j] = $root.mb_info.toObject(message.mb[j], options);
        }
        return object;
    };

    /**
     * Converts this mb_list to JSON.
     * @function toJSON
     * @memberof mb_list
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    mb_list.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for mb_list
     * @function getTypeUrl
     * @memberof mb_list
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    mb_list.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/mb_list";
    };

    return mb_list;
})();

export const mb_info = $root.mb_info = (() => {

    /**
     * Properties of a mb_info.
     * @exports Imb_info
     * @interface Imb_info
     * @property {string|null} [name] mb_info name
     * @property {string|null} [type] mb_info type
     * @property {string|null} [description] mb_info description
     * @property {Array.<Im_point>|null} [points] mb_info points
     */

    /**
     * Constructs a new mb_info.
     * @exports mb_info
     * @classdesc Represents a mb_info.
     * @implements Imb_info
     * @constructor
     * @param {Imb_info=} [properties] Properties to set
     */
    function mb_info(properties) {
        this.points = [];
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * mb_info name.
     * @member {string} name
     * @memberof mb_info
     * @instance
     */
    mb_info.prototype.name = "";

    /**
     * mb_info type.
     * @member {string} type
     * @memberof mb_info
     * @instance
     */
    mb_info.prototype.type = "";

    /**
     * mb_info description.
     * @member {string} description
     * @memberof mb_info
     * @instance
     */
    mb_info.prototype.description = "";

    /**
     * mb_info points.
     * @member {Array.<Im_point>} points
     * @memberof mb_info
     * @instance
     */
    mb_info.prototype.points = $util.emptyArray;

    /**
     * Creates a new mb_info instance using the specified properties.
     * @function create
     * @memberof mb_info
     * @static
     * @param {Imb_info=} [properties] Properties to set
     * @returns {mb_info} mb_info instance
     */
    mb_info.create = function create(properties) {
        return new mb_info(properties);
    };

    /**
     * Encodes the specified mb_info message. Does not implicitly {@link mb_info.verify|verify} messages.
     * @function encode
     * @memberof mb_info
     * @static
     * @param {Imb_info} message mb_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    mb_info.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.type != null && Object.hasOwnProperty.call(message, "type"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.type);
        if (message.description != null && Object.hasOwnProperty.call(message, "description"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.description);
        if (message.points != null && message.points.length)
            for (let i = 0; i < message.points.length; ++i)
                $root.m_point.encode(message.points[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified mb_info message, length delimited. Does not implicitly {@link mb_info.verify|verify} messages.
     * @function encodeDelimited
     * @memberof mb_info
     * @static
     * @param {Imb_info} message mb_info message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    mb_info.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a mb_info message from the specified reader or buffer.
     * @function decode
     * @memberof mb_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {mb_info} mb_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    mb_info.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.mb_info();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.type = reader.string();
                    break;
                }
            case 3: {
                    message.description = reader.string();
                    break;
                }
            case 4: {
                    if (!(message.points && message.points.length))
                        message.points = [];
                    message.points.push($root.m_point.decode(reader, reader.uint32()));
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a mb_info message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof mb_info
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {mb_info} mb_info
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    mb_info.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a mb_info message.
     * @function verify
     * @memberof mb_info
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    mb_info.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.type != null && message.hasOwnProperty("type"))
            if (!$util.isString(message.type))
                return "type: string expected";
        if (message.description != null && message.hasOwnProperty("description"))
            if (!$util.isString(message.description))
                return "description: string expected";
        if (message.points != null && message.hasOwnProperty("points")) {
            if (!Array.isArray(message.points))
                return "points: array expected";
            for (let i = 0; i < message.points.length; ++i) {
                let error = $root.m_point.verify(message.points[i]);
                if (error)
                    return "points." + error;
            }
        }
        return null;
    };

    /**
     * Creates a mb_info message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof mb_info
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {mb_info} mb_info
     */
    mb_info.fromObject = function fromObject(object) {
        if (object instanceof $root.mb_info)
            return object;
        let message = new $root.mb_info();
        if (object.name != null)
            message.name = String(object.name);
        if (object.type != null)
            message.type = String(object.type);
        if (object.description != null)
            message.description = String(object.description);
        if (object.points) {
            if (!Array.isArray(object.points))
                throw TypeError(".mb_info.points: array expected");
            message.points = [];
            for (let i = 0; i < object.points.length; ++i) {
                if (typeof object.points[i] !== "object")
                    throw TypeError(".mb_info.points: object expected");
                message.points[i] = $root.m_point.fromObject(object.points[i]);
            }
        }
        return message;
    };

    /**
     * Creates a plain object from a mb_info message. Also converts values to other types if specified.
     * @function toObject
     * @memberof mb_info
     * @static
     * @param {mb_info} message mb_info
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    mb_info.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.arrays || options.defaults)
            object.points = [];
        if (options.defaults) {
            object.name = "";
            object.type = "";
            object.description = "";
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.type != null && message.hasOwnProperty("type"))
            object.type = message.type;
        if (message.description != null && message.hasOwnProperty("description"))
            object.description = message.description;
        if (message.points && message.points.length) {
            object.points = [];
            for (let j = 0; j < message.points.length; ++j)
                object.points[j] = $root.m_point.toObject(message.points[j], options);
        }
        return object;
    };

    /**
     * Converts this mb_info to JSON.
     * @function toJSON
     * @memberof mb_info
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    mb_info.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for mb_info
     * @function getTypeUrl
     * @memberof mb_info
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    mb_info.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/mb_info";
    };

    return mb_info;
})();

export const user = $root.user = (() => {

    /**
     * Properties of a user.
     * @exports Iuser
     * @interface Iuser
     * @property {string|null} [name] user name
     * @property {string|null} [password] user password
     * @property {number|Long|null} [timestamp] user timestamp
     */

    /**
     * Constructs a new user.
     * @exports user
     * @classdesc Represents a user.
     * @implements Iuser
     * @constructor
     * @param {Iuser=} [properties] Properties to set
     */
    function user(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * user name.
     * @member {string} name
     * @memberof user
     * @instance
     */
    user.prototype.name = "";

    /**
     * user password.
     * @member {string} password
     * @memberof user
     * @instance
     */
    user.prototype.password = "";

    /**
     * user timestamp.
     * @member {number|Long} timestamp
     * @memberof user
     * @instance
     */
    user.prototype.timestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

    /**
     * Creates a new user instance using the specified properties.
     * @function create
     * @memberof user
     * @static
     * @param {Iuser=} [properties] Properties to set
     * @returns {user} user instance
     */
    user.create = function create(properties) {
        return new user(properties);
    };

    /**
     * Encodes the specified user message. Does not implicitly {@link user.verify|verify} messages.
     * @function encode
     * @memberof user
     * @static
     * @param {Iuser} message user message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    user.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.password != null && Object.hasOwnProperty.call(message, "password"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.password);
        if (message.timestamp != null && Object.hasOwnProperty.call(message, "timestamp"))
            writer.uint32(/* id 3, wireType 1 =*/25).fixed64(message.timestamp);
        return writer;
    };

    /**
     * Encodes the specified user message, length delimited. Does not implicitly {@link user.verify|verify} messages.
     * @function encodeDelimited
     * @memberof user
     * @static
     * @param {Iuser} message user message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    user.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a user message from the specified reader or buffer.
     * @function decode
     * @memberof user
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {user} user
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    user.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.user();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.password = reader.string();
                    break;
                }
            case 3: {
                    message.timestamp = reader.fixed64();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a user message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof user
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {user} user
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    user.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a user message.
     * @function verify
     * @memberof user
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    user.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.password != null && message.hasOwnProperty("password"))
            if (!$util.isString(message.password))
                return "password: string expected";
        if (message.timestamp != null && message.hasOwnProperty("timestamp"))
            if (!$util.isInteger(message.timestamp) && !(message.timestamp && $util.isInteger(message.timestamp.low) && $util.isInteger(message.timestamp.high)))
                return "timestamp: integer|Long expected";
        return null;
    };

    /**
     * Creates a user message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof user
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {user} user
     */
    user.fromObject = function fromObject(object) {
        if (object instanceof $root.user)
            return object;
        let message = new $root.user();
        if (object.name != null)
            message.name = String(object.name);
        if (object.password != null)
            message.password = String(object.password);
        if (object.timestamp != null)
            if ($util.Long)
                (message.timestamp = $util.Long.fromValue(object.timestamp)).unsigned = false;
            else if (typeof object.timestamp === "string")
                message.timestamp = parseInt(object.timestamp, 10);
            else if (typeof object.timestamp === "number")
                message.timestamp = object.timestamp;
            else if (typeof object.timestamp === "object")
                message.timestamp = new $util.LongBits(object.timestamp.low >>> 0, object.timestamp.high >>> 0).toNumber();
        return message;
    };

    /**
     * Creates a plain object from a user message. Also converts values to other types if specified.
     * @function toObject
     * @memberof user
     * @static
     * @param {user} message user
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    user.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.password = "";
            if ($util.Long) {
                let long = new $util.Long(0, 0, false);
                object.timestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
            } else
                object.timestamp = options.longs === String ? "0" : 0;
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.password != null && message.hasOwnProperty("password"))
            object.password = message.password;
        if (message.timestamp != null && message.hasOwnProperty("timestamp"))
            if (typeof message.timestamp === "number")
                object.timestamp = options.longs === String ? String(message.timestamp) : message.timestamp;
            else
                object.timestamp = options.longs === String ? $util.Long.prototype.toString.call(message.timestamp) : options.longs === Number ? new $util.LongBits(message.timestamp.low >>> 0, message.timestamp.high >>> 0).toNumber() : message.timestamp;
        return object;
    };

    /**
     * Converts this user to JSON.
     * @function toJSON
     * @memberof user
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    user.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for user
     * @function getTypeUrl
     * @memberof user
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    user.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/user";
    };

    return user;
})();

export const token = $root.token = (() => {

    /**
     * Properties of a token.
     * @exports Itoken
     * @interface Itoken
     * @property {string|null} [name] token name
     * @property {string|null} [token] token token
     * @property {number|Long|null} [timestamp] token timestamp
     * @property {number|Long|null} [expirationTime] token expirationTime
     */

    /**
     * Constructs a new token.
     * @exports token
     * @classdesc Represents a token.
     * @implements Itoken
     * @constructor
     * @param {Itoken=} [properties] Properties to set
     */
    function token(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * token name.
     * @member {string} name
     * @memberof token
     * @instance
     */
    token.prototype.name = "";

    /**
     * token token.
     * @member {string} token
     * @memberof token
     * @instance
     */
    token.prototype.token = "";

    /**
     * token timestamp.
     * @member {number|Long} timestamp
     * @memberof token
     * @instance
     */
    token.prototype.timestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

    /**
     * token expirationTime.
     * @member {number|Long} expirationTime
     * @memberof token
     * @instance
     */
    token.prototype.expirationTime = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

    /**
     * Creates a new token instance using the specified properties.
     * @function create
     * @memberof token
     * @static
     * @param {Itoken=} [properties] Properties to set
     * @returns {token} token instance
     */
    token.create = function create(properties) {
        return new token(properties);
    };

    /**
     * Encodes the specified token message. Does not implicitly {@link token.verify|verify} messages.
     * @function encode
     * @memberof token
     * @static
     * @param {Itoken} message token message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    token.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.token != null && Object.hasOwnProperty.call(message, "token"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.token);
        if (message.timestamp != null && Object.hasOwnProperty.call(message, "timestamp"))
            writer.uint32(/* id 3, wireType 1 =*/25).fixed64(message.timestamp);
        if (message.expirationTime != null && Object.hasOwnProperty.call(message, "expirationTime"))
            writer.uint32(/* id 4, wireType 1 =*/33).fixed64(message.expirationTime);
        return writer;
    };

    /**
     * Encodes the specified token message, length delimited. Does not implicitly {@link token.verify|verify} messages.
     * @function encodeDelimited
     * @memberof token
     * @static
     * @param {Itoken} message token message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    token.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a token message from the specified reader or buffer.
     * @function decode
     * @memberof token
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {token} token
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    token.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.token();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.token = reader.string();
                    break;
                }
            case 3: {
                    message.timestamp = reader.fixed64();
                    break;
                }
            case 4: {
                    message.expirationTime = reader.fixed64();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a token message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof token
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {token} token
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    token.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a token message.
     * @function verify
     * @memberof token
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    token.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.token != null && message.hasOwnProperty("token"))
            if (!$util.isString(message.token))
                return "token: string expected";
        if (message.timestamp != null && message.hasOwnProperty("timestamp"))
            if (!$util.isInteger(message.timestamp) && !(message.timestamp && $util.isInteger(message.timestamp.low) && $util.isInteger(message.timestamp.high)))
                return "timestamp: integer|Long expected";
        if (message.expirationTime != null && message.hasOwnProperty("expirationTime"))
            if (!$util.isInteger(message.expirationTime) && !(message.expirationTime && $util.isInteger(message.expirationTime.low) && $util.isInteger(message.expirationTime.high)))
                return "expirationTime: integer|Long expected";
        return null;
    };

    /**
     * Creates a token message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof token
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {token} token
     */
    token.fromObject = function fromObject(object) {
        if (object instanceof $root.token)
            return object;
        let message = new $root.token();
        if (object.name != null)
            message.name = String(object.name);
        if (object.token != null)
            message.token = String(object.token);
        if (object.timestamp != null)
            if ($util.Long)
                (message.timestamp = $util.Long.fromValue(object.timestamp)).unsigned = false;
            else if (typeof object.timestamp === "string")
                message.timestamp = parseInt(object.timestamp, 10);
            else if (typeof object.timestamp === "number")
                message.timestamp = object.timestamp;
            else if (typeof object.timestamp === "object")
                message.timestamp = new $util.LongBits(object.timestamp.low >>> 0, object.timestamp.high >>> 0).toNumber();
        if (object.expirationTime != null)
            if ($util.Long)
                (message.expirationTime = $util.Long.fromValue(object.expirationTime)).unsigned = false;
            else if (typeof object.expirationTime === "string")
                message.expirationTime = parseInt(object.expirationTime, 10);
            else if (typeof object.expirationTime === "number")
                message.expirationTime = object.expirationTime;
            else if (typeof object.expirationTime === "object")
                message.expirationTime = new $util.LongBits(object.expirationTime.low >>> 0, object.expirationTime.high >>> 0).toNumber();
        return message;
    };

    /**
     * Creates a plain object from a token message. Also converts values to other types if specified.
     * @function toObject
     * @memberof token
     * @static
     * @param {token} message token
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    token.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.token = "";
            if ($util.Long) {
                let long = new $util.Long(0, 0, false);
                object.timestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
            } else
                object.timestamp = options.longs === String ? "0" : 0;
            if ($util.Long) {
                let long = new $util.Long(0, 0, false);
                object.expirationTime = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
            } else
                object.expirationTime = options.longs === String ? "0" : 0;
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.token != null && message.hasOwnProperty("token"))
            object.token = message.token;
        if (message.timestamp != null && message.hasOwnProperty("timestamp"))
            if (typeof message.timestamp === "number")
                object.timestamp = options.longs === String ? String(message.timestamp) : message.timestamp;
            else
                object.timestamp = options.longs === String ? $util.Long.prototype.toString.call(message.timestamp) : options.longs === Number ? new $util.LongBits(message.timestamp.low >>> 0, message.timestamp.high >>> 0).toNumber() : message.timestamp;
        if (message.expirationTime != null && message.hasOwnProperty("expirationTime"))
            if (typeof message.expirationTime === "number")
                object.expirationTime = options.longs === String ? String(message.expirationTime) : message.expirationTime;
            else
                object.expirationTime = options.longs === String ? $util.Long.prototype.toString.call(message.expirationTime) : options.longs === Number ? new $util.LongBits(message.expirationTime.low >>> 0, message.expirationTime.high >>> 0).toNumber() : message.expirationTime;
        return object;
    };

    /**
     * Converts this token to JSON.
     * @function toJSON
     * @memberof token
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    token.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for token
     * @function getTypeUrl
     * @memberof token
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    token.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/token";
    };

    return token;
})();

export const passwd = $root.passwd = (() => {

    /**
     * Properties of a passwd.
     * @exports Ipasswd
     * @interface Ipasswd
     * @property {string|null} [name] passwd name
     * @property {string|null} [oldPassword] passwd oldPassword
     * @property {string|null} [newPassword] passwd newPassword
     * @property {string|null} [newPassword2] passwd newPassword2
     */

    /**
     * Constructs a new passwd.
     * @exports passwd
     * @classdesc Represents a passwd.
     * @implements Ipasswd
     * @constructor
     * @param {Ipasswd=} [properties] Properties to set
     */
    function passwd(properties) {
        if (properties)
            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * passwd name.
     * @member {string} name
     * @memberof passwd
     * @instance
     */
    passwd.prototype.name = "";

    /**
     * passwd oldPassword.
     * @member {string} oldPassword
     * @memberof passwd
     * @instance
     */
    passwd.prototype.oldPassword = "";

    /**
     * passwd newPassword.
     * @member {string} newPassword
     * @memberof passwd
     * @instance
     */
    passwd.prototype.newPassword = "";

    /**
     * passwd newPassword2.
     * @member {string} newPassword2
     * @memberof passwd
     * @instance
     */
    passwd.prototype.newPassword2 = "";

    /**
     * Creates a new passwd instance using the specified properties.
     * @function create
     * @memberof passwd
     * @static
     * @param {Ipasswd=} [properties] Properties to set
     * @returns {passwd} passwd instance
     */
    passwd.create = function create(properties) {
        return new passwd(properties);
    };

    /**
     * Encodes the specified passwd message. Does not implicitly {@link passwd.verify|verify} messages.
     * @function encode
     * @memberof passwd
     * @static
     * @param {Ipasswd} message passwd message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    passwd.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.name != null && Object.hasOwnProperty.call(message, "name"))
            writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
        if (message.oldPassword != null && Object.hasOwnProperty.call(message, "oldPassword"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.oldPassword);
        if (message.newPassword != null && Object.hasOwnProperty.call(message, "newPassword"))
            writer.uint32(/* id 3, wireType 2 =*/26).string(message.newPassword);
        if (message.newPassword2 != null && Object.hasOwnProperty.call(message, "newPassword2"))
            writer.uint32(/* id 4, wireType 2 =*/34).string(message.newPassword2);
        return writer;
    };

    /**
     * Encodes the specified passwd message, length delimited. Does not implicitly {@link passwd.verify|verify} messages.
     * @function encodeDelimited
     * @memberof passwd
     * @static
     * @param {Ipasswd} message passwd message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    passwd.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a passwd message from the specified reader or buffer.
     * @function decode
     * @memberof passwd
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {passwd} passwd
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    passwd.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        let end = length === undefined ? reader.len : reader.pos + length, message = new $root.passwd();
        while (reader.pos < end) {
            let tag = reader.uint32();
            switch (tag >>> 3) {
            case 1: {
                    message.name = reader.string();
                    break;
                }
            case 2: {
                    message.oldPassword = reader.string();
                    break;
                }
            case 3: {
                    message.newPassword = reader.string();
                    break;
                }
            case 4: {
                    message.newPassword2 = reader.string();
                    break;
                }
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a passwd message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof passwd
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {passwd} passwd
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    passwd.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a passwd message.
     * @function verify
     * @memberof passwd
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    passwd.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.name != null && message.hasOwnProperty("name"))
            if (!$util.isString(message.name))
                return "name: string expected";
        if (message.oldPassword != null && message.hasOwnProperty("oldPassword"))
            if (!$util.isString(message.oldPassword))
                return "oldPassword: string expected";
        if (message.newPassword != null && message.hasOwnProperty("newPassword"))
            if (!$util.isString(message.newPassword))
                return "newPassword: string expected";
        if (message.newPassword2 != null && message.hasOwnProperty("newPassword2"))
            if (!$util.isString(message.newPassword2))
                return "newPassword2: string expected";
        return null;
    };

    /**
     * Creates a passwd message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof passwd
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {passwd} passwd
     */
    passwd.fromObject = function fromObject(object) {
        if (object instanceof $root.passwd)
            return object;
        let message = new $root.passwd();
        if (object.name != null)
            message.name = String(object.name);
        if (object.oldPassword != null)
            message.oldPassword = String(object.oldPassword);
        if (object.newPassword != null)
            message.newPassword = String(object.newPassword);
        if (object.newPassword2 != null)
            message.newPassword2 = String(object.newPassword2);
        return message;
    };

    /**
     * Creates a plain object from a passwd message. Also converts values to other types if specified.
     * @function toObject
     * @memberof passwd
     * @static
     * @param {passwd} message passwd
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    passwd.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        let object = {};
        if (options.defaults) {
            object.name = "";
            object.oldPassword = "";
            object.newPassword = "";
            object.newPassword2 = "";
        }
        if (message.name != null && message.hasOwnProperty("name"))
            object.name = message.name;
        if (message.oldPassword != null && message.hasOwnProperty("oldPassword"))
            object.oldPassword = message.oldPassword;
        if (message.newPassword != null && message.hasOwnProperty("newPassword"))
            object.newPassword = message.newPassword;
        if (message.newPassword2 != null && message.hasOwnProperty("newPassword2"))
            object.newPassword2 = message.newPassword2;
        return object;
    };

    /**
     * Converts this passwd to JSON.
     * @function toJSON
     * @memberof passwd
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    passwd.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    /**
     * Gets the default type url for passwd
     * @function getTypeUrl
     * @memberof passwd
     * @static
     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
     * @returns {string} The default type url
     */
    passwd.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
        if (typeUrlPrefix === undefined) {
            typeUrlPrefix = "type.googleapis.com";
        }
        return typeUrlPrefix + "/passwd";
    };

    return passwd;
})();

export { $root as default };
