/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
"use strict";

var $protobuf = protobuf;

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

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

$root.baseproto = (function() {

    /**
     * Namespace baseproto.
     * @exports baseproto
     * @namespace
     */
    var baseproto = {};

    /**
     * ENUM_MAIN_ID enum.
     * @name baseproto.ENUM_MAIN_ID
     * @enum {number}
     * @property {number} UNUSED=0 UNUSED value
     * @property {number} TOKEN_ID=1 TOKEN_ID value
     * @property {number} LOGIN_ID=2 LOGIN_ID value
     * @property {number} HALL_ID=3 HALL_ID value
     * @property {number} GAME_ID=4 GAME_ID value
     */
    baseproto.ENUM_MAIN_ID = (function() {
        var valuesById = {}, values = Object.create(valuesById);
        values[valuesById[0] = "UNUSED"] = 0;
        values[valuesById[1] = "TOKEN_ID"] = 1;
        values[valuesById[2] = "LOGIN_ID"] = 2;
        values[valuesById[3] = "HALL_ID"] = 3;
        values[valuesById[4] = "GAME_ID"] = 4;
        return values;
    })();

    /**
     * ENUM_ERRO_ID enum.
     * @name baseproto.ENUM_ERRO_ID
     * @enum {number}
     * @property {number} PACKAGE_ERRO=-1 PACKAGE_ERRO value
     * @property {number} MAIN_SUB_ERRO=-2 MAIN_SUB_ERRO value
     * @property {number} BODY_ERRO=-3 BODY_ERRO value
     * @property {number} DB_ERRO=-4 DB_ERRO value
     */
    baseproto.ENUM_ERRO_ID = (function() {
        var valuesById = {}, values = Object.create(valuesById);
        values[valuesById[-1] = "PACKAGE_ERRO"] = -1;
        values[valuesById[-2] = "MAIN_SUB_ERRO"] = -2;
        values[valuesById[-3] = "BODY_ERRO"] = -3;
        values[valuesById[-4] = "DB_ERRO"] = -4;
        return values;
    })();

    baseproto.Msg_Head = (function() {

        /**
         * Properties of a Msg_Head.
         * @memberof baseproto
         * @interface IMsg_Head
         * @property {number|null} [wMainCmdID] Msg_Head wMainCmdID
         * @property {number|null} [wSubCmdID] Msg_Head wSubCmdID
         * @property {Uint8Array|null} [msgBody] Msg_Head msgBody
         */

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

        /**
         * Msg_Head wMainCmdID.
         * @member {number} wMainCmdID
         * @memberof baseproto.Msg_Head
         * @instance
         */
        Msg_Head.prototype.wMainCmdID = 0;

        /**
         * Msg_Head wSubCmdID.
         * @member {number} wSubCmdID
         * @memberof baseproto.Msg_Head
         * @instance
         */
        Msg_Head.prototype.wSubCmdID = 0;

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

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

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

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

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

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

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

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

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

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

        return Msg_Head;
    })();

    baseproto.Msg_TokenBody = (function() {

        /**
         * Properties of a Msg_TokenBody.
         * @memberof baseproto
         * @interface IMsg_TokenBody
         * @property {string|null} [strToken] Msg_TokenBody strToken
         * @property {Uint8Array|null} [msgBody] Msg_TokenBody msgBody
         */

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

        /**
         * Msg_TokenBody strToken.
         * @member {string} strToken
         * @memberof baseproto.Msg_TokenBody
         * @instance
         */
        Msg_TokenBody.prototype.strToken = "";

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

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

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

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

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

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

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

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

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

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

        return Msg_TokenBody;
    })();

    baseproto.Msg_Info = (function() {

        /**
         * Properties of a Msg_Info.
         * @memberof baseproto
         * @interface IMsg_Info
         * @property {number|null} [cbDataKind] Msg_Info cbDataKind
         * @property {number|null} [wPacketSize] Msg_Info wPacketSize
         * @property {Uint8Array|null} [msgBuff] Msg_Info msgBuff
         */

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

        /**
         * Msg_Info cbDataKind.
         * @member {number} cbDataKind
         * @memberof baseproto.Msg_Info
         * @instance
         */
        Msg_Info.prototype.cbDataKind = 0;

        /**
         * Msg_Info wPacketSize.
         * @member {number} wPacketSize
         * @memberof baseproto.Msg_Info
         * @instance
         */
        Msg_Info.prototype.wPacketSize = 0;

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

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

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

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

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

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

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

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

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

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

        return Msg_Info;
    })();

    baseproto.MsgBodyErro = (function() {

        /**
         * Properties of a MsgBodyErro.
         * @memberof baseproto
         * @interface IMsgBodyErro
         * @property {number|null} [code] MsgBodyErro code
         * @property {string|null} [disp] MsgBodyErro disp
         */

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

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

        /**
         * MsgBodyErro disp.
         * @member {string} disp
         * @memberof baseproto.MsgBodyErro
         * @instance
         */
        MsgBodyErro.prototype.disp = "";

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

        /**
         * Encodes the specified MsgBodyErro message. Does not implicitly {@link baseproto.MsgBodyErro.verify|verify} messages.
         * @function encode
         * @memberof baseproto.MsgBodyErro
         * @static
         * @param {baseproto.IMsgBodyErro} message MsgBodyErro message or plain object to encode
         * @param {$protobuf.Writer} [writer] Writer to encode to
         * @returns {$protobuf.Writer} Writer
         */
        MsgBodyErro.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.disp != null && Object.hasOwnProperty.call(message, "disp"))
                writer.uint32(/* id 2, wireType 2 =*/18).string(message.disp);
            return writer;
        };

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

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

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

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

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

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

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

        return MsgBodyErro;
    })();

    return baseproto;
})();

module.exports = $root;