@ycryptx/tiktok-live-connector/dist/proto/tiktokSchema.js

Node.js module to receive live stream chat events like comments and gifts from TikTok LIVE

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.decodeEmoteDetails = decodeEmoteDetails;
exports.decodeEmoteImage = decodeEmoteImage;
exports.decodeFollowInfo = decodeFollowInfo;
exports.decodeLinkUser = decodeLinkUser;
exports.decodeMessage = decodeMessage;
exports.decodePrivilegeLogExtra = decodePrivilegeLogExtra;
exports.decodeProfilePicture = decodeProfilePicture;
exports.decodeQuestionDetails = decodeQuestionDetails;
exports.decodeRankContainer = decodeRankContainer;
exports.decodeRankItem = decodeRankItem;
exports.decodeSystemMessage = decodeSystemMessage;
exports.decodeTopUser = decodeTopUser;
exports.decodeTreasureBoxData = decodeTreasureBoxData;
exports.decodeTreasureBoxUser = decodeTreasureBoxUser;
exports.decodeTreasureBoxUser2 = decodeTreasureBoxUser2;
exports.decodeTreasureBoxUser3 = decodeTreasureBoxUser3;
exports.decodeTreasureBoxUser4 = decodeTreasureBoxUser4;
exports.decodeUser = decodeUser;
exports.decodeUserBadge = decodeUserBadge;
exports.decodeUserBadgesAttributes = decodeUserBadgesAttributes;
exports.decodeUserImageBadge = decodeUserImageBadge;
exports.decodeUserImageBadgeImage = decodeUserImageBadgeImage;
exports.decodeWebcastChatMessage = decodeWebcastChatMessage;
exports.decodeWebcastControlMessage = decodeWebcastControlMessage;
exports.decodeWebcastEmoteChatMessage = decodeWebcastEmoteChatMessage;
exports.decodeWebcastEnvelopeMessage = decodeWebcastEnvelopeMessage;
exports.decodeWebcastGiftMessage = decodeWebcastGiftMessage;
exports.decodeWebcastGiftMessageGiftDetails = decodeWebcastGiftMessageGiftDetails;
exports.decodeWebcastGiftMessageGiftExtra = decodeWebcastGiftMessageGiftExtra;
exports.decodeWebcastGiftMessageGiftImage = decodeWebcastGiftMessageGiftImage;
exports.decodeWebcastHourlyRankMessage = decodeWebcastHourlyRankMessage;
exports.decodeWebcastInRoomBannerMessage = decodeWebcastInRoomBannerMessage;
exports.decodeWebcastLikeMessage = decodeWebcastLikeMessage;
exports.decodeWebcastLinkMicArmies = decodeWebcastLinkMicArmies;
exports.decodeWebcastLinkMicArmiesGroup = decodeWebcastLinkMicArmiesGroup;
exports.decodeWebcastLinkMicArmiesItems = decodeWebcastLinkMicArmiesItems;
exports.decodeWebcastLinkMicBattle = decodeWebcastLinkMicBattle;
exports.decodeWebcastLinkMicBattleGroup = decodeWebcastLinkMicBattleGroup;
exports.decodeWebcastLinkMicBattleItems = decodeWebcastLinkMicBattleItems;
exports.decodeWebcastLiveIntroMessage = decodeWebcastLiveIntroMessage;
exports.decodeWebcastMemberMessage = decodeWebcastMemberMessage;
exports.decodeWebcastMessageEvent = decodeWebcastMessageEvent;
exports.decodeWebcastMessageEventDetails = decodeWebcastMessageEventDetails;
exports.decodeWebcastQuestionNewMessage = decodeWebcastQuestionNewMessage;
exports.decodeWebcastResponse = decodeWebcastResponse;
exports.decodeWebcastRoomUserSeqMessage = decodeWebcastRoomUserSeqMessage;
exports.decodeWebcastSocialMessage = decodeWebcastSocialMessage;
exports.decodeWebcastSubEmote = decodeWebcastSubEmote;
exports.decodeWebcastSubNotifyMessage = decodeWebcastSubNotifyMessage;
exports.decodeWebcastWebsocketAck = decodeWebcastWebsocketAck;
exports.decodeWebcastWebsocketMessage = decodeWebcastWebsocketMessage;
exports.decodeWebsocketParam = decodeWebsocketParam;
exports.decodeWeeklyRanking = decodeWeeklyRanking;
exports.encodeEmoteDetails = encodeEmoteDetails;
exports.encodeEmoteImage = encodeEmoteImage;
exports.encodeFollowInfo = encodeFollowInfo;
exports.encodeLinkUser = encodeLinkUser;
exports.encodeMessage = encodeMessage;
exports.encodePrivilegeLogExtra = encodePrivilegeLogExtra;
exports.encodeProfilePicture = encodeProfilePicture;
exports.encodeQuestionDetails = encodeQuestionDetails;
exports.encodeRankContainer = encodeRankContainer;
exports.encodeRankItem = encodeRankItem;
exports.encodeSystemMessage = encodeSystemMessage;
exports.encodeTopUser = encodeTopUser;
exports.encodeTreasureBoxData = encodeTreasureBoxData;
exports.encodeTreasureBoxUser = encodeTreasureBoxUser;
exports.encodeTreasureBoxUser2 = encodeTreasureBoxUser2;
exports.encodeTreasureBoxUser3 = encodeTreasureBoxUser3;
exports.encodeTreasureBoxUser4 = encodeTreasureBoxUser4;
exports.encodeUser = encodeUser;
exports.encodeUserBadge = encodeUserBadge;
exports.encodeUserBadgesAttributes = encodeUserBadgesAttributes;
exports.encodeUserImageBadge = encodeUserImageBadge;
exports.encodeUserImageBadgeImage = encodeUserImageBadgeImage;
exports.encodeWebcastChatMessage = encodeWebcastChatMessage;
exports.encodeWebcastControlMessage = encodeWebcastControlMessage;
exports.encodeWebcastEmoteChatMessage = encodeWebcastEmoteChatMessage;
exports.encodeWebcastEnvelopeMessage = encodeWebcastEnvelopeMessage;
exports.encodeWebcastGiftMessage = encodeWebcastGiftMessage;
exports.encodeWebcastGiftMessageGiftDetails = encodeWebcastGiftMessageGiftDetails;
exports.encodeWebcastGiftMessageGiftExtra = encodeWebcastGiftMessageGiftExtra;
exports.encodeWebcastGiftMessageGiftImage = encodeWebcastGiftMessageGiftImage;
exports.encodeWebcastHourlyRankMessage = encodeWebcastHourlyRankMessage;
exports.encodeWebcastInRoomBannerMessage = encodeWebcastInRoomBannerMessage;
exports.encodeWebcastLikeMessage = encodeWebcastLikeMessage;
exports.encodeWebcastLinkMicArmies = encodeWebcastLinkMicArmies;
exports.encodeWebcastLinkMicArmiesGroup = encodeWebcastLinkMicArmiesGroup;
exports.encodeWebcastLinkMicArmiesItems = encodeWebcastLinkMicArmiesItems;
exports.encodeWebcastLinkMicBattle = encodeWebcastLinkMicBattle;
exports.encodeWebcastLinkMicBattleGroup = encodeWebcastLinkMicBattleGroup;
exports.encodeWebcastLinkMicBattleItems = encodeWebcastLinkMicBattleItems;
exports.encodeWebcastLiveIntroMessage = encodeWebcastLiveIntroMessage;
exports.encodeWebcastMemberMessage = encodeWebcastMemberMessage;
exports.encodeWebcastMessageEvent = encodeWebcastMessageEvent;
exports.encodeWebcastMessageEventDetails = encodeWebcastMessageEventDetails;
exports.encodeWebcastQuestionNewMessage = encodeWebcastQuestionNewMessage;
exports.encodeWebcastResponse = encodeWebcastResponse;
exports.encodeWebcastRoomUserSeqMessage = encodeWebcastRoomUserSeqMessage;
exports.encodeWebcastSocialMessage = encodeWebcastSocialMessage;
exports.encodeWebcastSubEmote = encodeWebcastSubEmote;
exports.encodeWebcastSubNotifyMessage = encodeWebcastSubNotifyMessage;
exports.encodeWebcastWebsocketAck = encodeWebcastWebsocketAck;
exports.encodeWebcastWebsocketMessage = encodeWebcastWebsocketMessage;
exports.encodeWebsocketParam = encodeWebsocketParam;
exports.encodeWeeklyRanking = encodeWeeklyRanking;

function encodeWebcastResponse(message) {
  let bb = popByteBuffer();

  _encodeWebcastResponse(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastResponse(message, bb) {
  // repeated Message messages = 1;
  let array$messages = message.messages;

  if (array$messages !== undefined) {
    for (let value of array$messages) {
      writeVarint32(bb, 10);
      let nested = popByteBuffer();

      _encodeMessage(value, nested);

      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  } // optional string cursor = 2;


  let $cursor = message.cursor;

  if ($cursor !== undefined) {
    writeVarint32(bb, 18);
    writeString(bb, $cursor);
  } // optional int32 fetchInterval = 3;


  let $fetchInterval = message.fetchInterval;

  if ($fetchInterval !== undefined) {
    writeVarint32(bb, 24);
    writeVarint64(bb, intToLong($fetchInterval));
  } // optional int64 serverTimestamp = 4;


  let $serverTimestamp = message.serverTimestamp;

  if ($serverTimestamp !== undefined) {
    writeVarint32(bb, 32);
    writeVarint64(bb, $serverTimestamp);
  } // optional string internalExt = 5;


  let $internalExt = message.internalExt;

  if ($internalExt !== undefined) {
    writeVarint32(bb, 42);
    writeString(bb, $internalExt);
  } // optional int32 fetchType = 6;


  let $fetchType = message.fetchType;

  if ($fetchType !== undefined) {
    writeVarint32(bb, 48);
    writeVarint64(bb, intToLong($fetchType));
  } // optional WebsocketParam wsParam = 7;


  let $wsParam = message.wsParam;

  if ($wsParam !== undefined) {
    writeVarint32(bb, 58);
    let nested = popByteBuffer();

    _encodeWebsocketParam($wsParam, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional int32 heartbeatDuration = 8;


  let $heartbeatDuration = message.heartbeatDuration;

  if ($heartbeatDuration !== undefined) {
    writeVarint32(bb, 64);
    writeVarint64(bb, intToLong($heartbeatDuration));
  } // optional bool needAck = 9;


  let $needAck = message.needAck;

  if ($needAck !== undefined) {
    writeVarint32(bb, 72);
    writeByte(bb, $needAck ? 1 : 0);
  } // optional string wsUrl = 10;


  let $wsUrl = message.wsUrl;

  if ($wsUrl !== undefined) {
    writeVarint32(bb, 82);
    writeString(bb, $wsUrl);
  }
}

function decodeWebcastResponse(binary) {
  return _decodeWebcastResponse(wrapByteBuffer(binary));
}

function _decodeWebcastResponse(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // repeated Message messages = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          let values = message.messages || (message.messages = []);
          values.push(_decodeMessage(bb));
          bb.limit = limit;
          break;
        }
      // optional string cursor = 2;

      case 2:
        {
          message.cursor = readString(bb, readVarint32(bb));
          break;
        }
      // optional int32 fetchInterval = 3;

      case 3:
        {
          message.fetchInterval = readVarint32(bb);
          break;
        }
      // optional int64 serverTimestamp = 4;

      case 4:
        {
          message.serverTimestamp = readVarint64(bb,
          /* unsigned */
          false);
          break;
        }
      // optional string internalExt = 5;

      case 5:
        {
          message.internalExt = readString(bb, readVarint32(bb));
          break;
        }
      // optional int32 fetchType = 6;

      case 6:
        {
          message.fetchType = readVarint32(bb);
          break;
        }
      // optional WebsocketParam wsParam = 7;

      case 7:
        {
          let limit = pushTemporaryLength(bb);
          message.wsParam = _decodeWebsocketParam(bb);
          bb.limit = limit;
          break;
        }
      // optional int32 heartbeatDuration = 8;

      case 8:
        {
          message.heartbeatDuration = readVarint32(bb);
          break;
        }
      // optional bool needAck = 9;

      case 9:
        {
          message.needAck = !!readByte(bb);
          break;
        }
      // optional string wsUrl = 10;

      case 10:
        {
          message.wsUrl = readString(bb, readVarint32(bb));
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeMessage(message) {
  let bb = popByteBuffer();

  _encodeMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeMessage(message, bb) {
  // optional string type = 1;
  let $type = message.type;

  if ($type !== undefined) {
    writeVarint32(bb, 10);
    writeString(bb, $type);
  } // optional bytes binary = 2;


  let $binary = message.binary;

  if ($binary !== undefined) {
    writeVarint32(bb, 18);
    writeVarint32(bb, $binary.length), writeBytes(bb, $binary);
  }
}

function decodeMessage(binary) {
  return _decodeMessage(wrapByteBuffer(binary));
}

function _decodeMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional string type = 1;

      case 1:
        {
          message.type = readString(bb, readVarint32(bb));
          break;
        }
      // optional bytes binary = 2;

      case 2:
        {
          message.binary = readBytes(bb, readVarint32(bb));
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebsocketParam(message) {
  let bb = popByteBuffer();

  _encodeWebsocketParam(message, bb);

  return toUint8Array(bb);
}

function _encodeWebsocketParam(message, bb) {
  // optional string name = 1;
  let $name = message.name;

  if ($name !== undefined) {
    writeVarint32(bb, 10);
    writeString(bb, $name);
  } // optional string value = 2;


  let $value = message.value;

  if ($value !== undefined) {
    writeVarint32(bb, 18);
    writeString(bb, $value);
  }
}

function decodeWebsocketParam(binary) {
  return _decodeWebsocketParam(wrapByteBuffer(binary));
}

function _decodeWebsocketParam(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional string name = 1;

      case 1:
        {
          message.name = readString(bb, readVarint32(bb));
          break;
        }
      // optional string value = 2;

      case 2:
        {
          message.value = readString(bb, readVarint32(bb));
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastControlMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastControlMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastControlMessage(message, bb) {
  // optional int32 action = 2;
  let $action = message.action;

  if ($action !== undefined) {
    writeVarint32(bb, 16);
    writeVarint64(bb, intToLong($action));
  }
}

function decodeWebcastControlMessage(binary) {
  return _decodeWebcastControlMessage(wrapByteBuffer(binary));
}

function _decodeWebcastControlMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional int32 action = 2;

      case 2:
        {
          message.action = readVarint32(bb);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastRoomUserSeqMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastRoomUserSeqMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastRoomUserSeqMessage(message, bb) {
  // repeated TopUser topViewers = 2;
  let array$topViewers = message.topViewers;

  if (array$topViewers !== undefined) {
    for (let value of array$topViewers) {
      writeVarint32(bb, 18);
      let nested = popByteBuffer();

      _encodeTopUser(value, nested);

      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  } // optional int32 viewerCount = 3;


  let $viewerCount = message.viewerCount;

  if ($viewerCount !== undefined) {
    writeVarint32(bb, 24);
    writeVarint64(bb, intToLong($viewerCount));
  }
}

function decodeWebcastRoomUserSeqMessage(binary) {
  return _decodeWebcastRoomUserSeqMessage(wrapByteBuffer(binary));
}

function _decodeWebcastRoomUserSeqMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // repeated TopUser topViewers = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          let values = message.topViewers || (message.topViewers = []);
          values.push(_decodeTopUser(bb));
          bb.limit = limit;
          break;
        }
      // optional int32 viewerCount = 3;

      case 3:
        {
          message.viewerCount = readVarint32(bb);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeTopUser(message) {
  let bb = popByteBuffer();

  _encodeTopUser(message, bb);

  return toUint8Array(bb);
}

function _encodeTopUser(message, bb) {
  // optional uint64 coinCount = 1;
  let $coinCount = message.coinCount;

  if ($coinCount !== undefined) {
    writeVarint32(bb, 8);
    writeVarint64(bb, $coinCount);
  } // optional User user = 2;


  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeTopUser(binary) {
  return _decodeTopUser(wrapByteBuffer(binary));
}

function _decodeTopUser(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional uint64 coinCount = 1;

      case 1:
        {
          message.coinCount = readVarint64(bb,
          /* unsigned */
          true);
          break;
        }
      // optional User user = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastChatMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastChatMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastChatMessage(message, bb) {
  // optional WebcastMessageEvent event = 1;
  let $event = message.event;

  if ($event !== undefined) {
    writeVarint32(bb, 10);
    let nested = popByteBuffer();

    _encodeWebcastMessageEvent($event, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional User user = 2;


  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional string comment = 3;


  let $comment = message.comment;

  if ($comment !== undefined) {
    writeVarint32(bb, 26);
    writeString(bb, $comment);
  } // repeated WebcastSubEmote emotes = 13;


  let array$emotes = message.emotes;

  if (array$emotes !== undefined) {
    for (let value of array$emotes) {
      writeVarint32(bb, 106);
      let nested = popByteBuffer();

      _encodeWebcastSubEmote(value, nested);

      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }
}

function decodeWebcastChatMessage(binary) {
  return _decodeWebcastChatMessage(wrapByteBuffer(binary));
}

function _decodeWebcastChatMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional WebcastMessageEvent event = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          message.event = _decodeWebcastMessageEvent(bb);
          bb.limit = limit;
          break;
        }
      // optional User user = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }
      // optional string comment = 3;

      case 3:
        {
          message.comment = readString(bb, readVarint32(bb));
          break;
        }
      // repeated WebcastSubEmote emotes = 13;

      case 13:
        {
          let limit = pushTemporaryLength(bb);
          let values = message.emotes || (message.emotes = []);
          values.push(_decodeWebcastSubEmote(bb));
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastEmoteChatMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastEmoteChatMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastEmoteChatMessage(message, bb) {
  // optional User user = 2;
  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional EmoteDetails emote = 3;


  let $emote = message.emote;

  if ($emote !== undefined) {
    writeVarint32(bb, 26);
    let nested = popByteBuffer();

    _encodeEmoteDetails($emote, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeWebcastEmoteChatMessage(binary) {
  return _decodeWebcastEmoteChatMessage(wrapByteBuffer(binary));
}

function _decodeWebcastEmoteChatMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional User user = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }
      // optional EmoteDetails emote = 3;

      case 3:
        {
          let limit = pushTemporaryLength(bb);
          message.emote = _decodeEmoteDetails(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastSubEmote(message) {
  let bb = popByteBuffer();

  _encodeWebcastSubEmote(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastSubEmote(message, bb) {
  // optional int32 placeInComment = 1;
  let $placeInComment = message.placeInComment;

  if ($placeInComment !== undefined) {
    writeVarint32(bb, 8);
    writeVarint64(bb, intToLong($placeInComment));
  } // optional EmoteDetails emote = 2;


  let $emote = message.emote;

  if ($emote !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeEmoteDetails($emote, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeWebcastSubEmote(binary) {
  return _decodeWebcastSubEmote(wrapByteBuffer(binary));
}

function _decodeWebcastSubEmote(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional int32 placeInComment = 1;

      case 1:
        {
          message.placeInComment = readVarint32(bb);
          break;
        }
      // optional EmoteDetails emote = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.emote = _decodeEmoteDetails(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastMemberMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastMemberMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastMemberMessage(message, bb) {
  // optional WebcastMessageEvent event = 1;
  let $event = message.event;

  if ($event !== undefined) {
    writeVarint32(bb, 10);
    let nested = popByteBuffer();

    _encodeWebcastMessageEvent($event, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional User user = 2;


  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional int32 actionId = 10;


  let $actionId = message.actionId;

  if ($actionId !== undefined) {
    writeVarint32(bb, 80);
    writeVarint64(bb, intToLong($actionId));
  }
}

function decodeWebcastMemberMessage(binary) {
  return _decodeWebcastMemberMessage(wrapByteBuffer(binary));
}

function _decodeWebcastMemberMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional WebcastMessageEvent event = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          message.event = _decodeWebcastMessageEvent(bb);
          bb.limit = limit;
          break;
        }
      // optional User user = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }
      // optional int32 actionId = 10;

      case 10:
        {
          message.actionId = readVarint32(bb);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastGiftMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastGiftMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastGiftMessage(message, bb) {
  // optional WebcastMessageEvent event = 1;
  let $event = message.event;

  if ($event !== undefined) {
    writeVarint32(bb, 10);
    let nested = popByteBuffer();

    _encodeWebcastMessageEvent($event, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional int32 giftId = 2;


  let $giftId = message.giftId;

  if ($giftId !== undefined) {
    writeVarint32(bb, 16);
    writeVarint64(bb, intToLong($giftId));
  } // optional int32 repeatCount = 5;


  let $repeatCount = message.repeatCount;

  if ($repeatCount !== undefined) {
    writeVarint32(bb, 40);
    writeVarint64(bb, intToLong($repeatCount));
  } // optional User user = 7;


  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 58);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional int32 repeatEnd = 9;


  let $repeatEnd = message.repeatEnd;

  if ($repeatEnd !== undefined) {
    writeVarint32(bb, 72);
    writeVarint64(bb, intToLong($repeatEnd));
  } // optional uint64 groupId = 11;


  let $groupId = message.groupId;

  if ($groupId !== undefined) {
    writeVarint32(bb, 88);
    writeVarint64(bb, $groupId);
  } // optional WebcastGiftMessageGiftDetails giftDetails = 15;


  let $giftDetails = message.giftDetails;

  if ($giftDetails !== undefined) {
    writeVarint32(bb, 122);
    let nested = popByteBuffer();

    _encodeWebcastGiftMessageGiftDetails($giftDetails, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional string monitorExtra = 22;


  let $monitorExtra = message.monitorExtra;

  if ($monitorExtra !== undefined) {
    writeVarint32(bb, 178);
    writeString(bb, $monitorExtra);
  } // optional WebcastGiftMessageGiftExtra giftExtra = 23;


  let $giftExtra = message.giftExtra;

  if ($giftExtra !== undefined) {
    writeVarint32(bb, 186);
    let nested = popByteBuffer();

    _encodeWebcastGiftMessageGiftExtra($giftExtra, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeWebcastGiftMessage(binary) {
  return _decodeWebcastGiftMessage(wrapByteBuffer(binary));
}

function _decodeWebcastGiftMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional WebcastMessageEvent event = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          message.event = _decodeWebcastMessageEvent(bb);
          bb.limit = limit;
          break;
        }
      // optional int32 giftId = 2;

      case 2:
        {
          message.giftId = readVarint32(bb);
          break;
        }
      // optional int32 repeatCount = 5;

      case 5:
        {
          message.repeatCount = readVarint32(bb);
          break;
        }
      // optional User user = 7;

      case 7:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }
      // optional int32 repeatEnd = 9;

      case 9:
        {
          message.repeatEnd = readVarint32(bb);
          break;
        }
      // optional uint64 groupId = 11;

      case 11:
        {
          message.groupId = readVarint64(bb,
          /* unsigned */
          true);
          break;
        }
      // optional WebcastGiftMessageGiftDetails giftDetails = 15;

      case 15:
        {
          let limit = pushTemporaryLength(bb);
          message.giftDetails = _decodeWebcastGiftMessageGiftDetails(bb);
          bb.limit = limit;
          break;
        }
      // optional string monitorExtra = 22;

      case 22:
        {
          message.monitorExtra = readString(bb, readVarint32(bb));
          break;
        }
      // optional WebcastGiftMessageGiftExtra giftExtra = 23;

      case 23:
        {
          let limit = pushTemporaryLength(bb);
          message.giftExtra = _decodeWebcastGiftMessageGiftExtra(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastGiftMessageGiftDetails(message) {
  let bb = popByteBuffer();

  _encodeWebcastGiftMessageGiftDetails(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastGiftMessageGiftDetails(message, bb) {
  // optional WebcastGiftMessageGiftImage giftImage = 1;
  let $giftImage = message.giftImage;

  if ($giftImage !== undefined) {
    writeVarint32(bb, 10);
    let nested = popByteBuffer();

    _encodeWebcastGiftMessageGiftImage($giftImage, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional string giftName = 16;


  let $giftName = message.giftName;

  if ($giftName !== undefined) {
    writeVarint32(bb, 130);
    writeString(bb, $giftName);
  } // optional string describe = 2;


  let $describe = message.describe;

  if ($describe !== undefined) {
    writeVarint32(bb, 18);
    writeString(bb, $describe);
  } // optional int32 giftType = 11;


  let $giftType = message.giftType;

  if ($giftType !== undefined) {
    writeVarint32(bb, 88);
    writeVarint64(bb, intToLong($giftType));
  } // optional int32 diamondCount = 12;


  let $diamondCount = message.diamondCount;

  if ($diamondCount !== undefined) {
    writeVarint32(bb, 96);
    writeVarint64(bb, intToLong($diamondCount));
  }
}

function decodeWebcastGiftMessageGiftDetails(binary) {
  return _decodeWebcastGiftMessageGiftDetails(wrapByteBuffer(binary));
}

function _decodeWebcastGiftMessageGiftDetails(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional WebcastGiftMessageGiftImage giftImage = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          message.giftImage = _decodeWebcastGiftMessageGiftImage(bb);
          bb.limit = limit;
          break;
        }
      // optional string giftName = 16;

      case 16:
        {
          message.giftName = readString(bb, readVarint32(bb));
          break;
        }
      // optional string describe = 2;

      case 2:
        {
          message.describe = readString(bb, readVarint32(bb));
          break;
        }
      // optional int32 giftType = 11;

      case 11:
        {
          message.giftType = readVarint32(bb);
          break;
        }
      // optional int32 diamondCount = 12;

      case 12:
        {
          message.diamondCount = readVarint32(bb);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastGiftMessageGiftExtra(message) {
  let bb = popByteBuffer();

  _encodeWebcastGiftMessageGiftExtra(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastGiftMessageGiftExtra(message, bb) {
  // optional uint64 timestamp = 6;
  let $timestamp = message.timestamp;

  if ($timestamp !== undefined) {
    writeVarint32(bb, 48);
    writeVarint64(bb, $timestamp);
  } // optional uint64 receiverUserId = 8;


  let $receiverUserId = message.receiverUserId;

  if ($receiverUserId !== undefined) {
    writeVarint32(bb, 64);
    writeVarint64(bb, $receiverUserId);
  }
}

function decodeWebcastGiftMessageGiftExtra(binary) {
  return _decodeWebcastGiftMessageGiftExtra(wrapByteBuffer(binary));
}

function _decodeWebcastGiftMessageGiftExtra(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional uint64 timestamp = 6;

      case 6:
        {
          message.timestamp = readVarint64(bb,
          /* unsigned */
          true);
          break;
        }
      // optional uint64 receiverUserId = 8;

      case 8:
        {
          message.receiverUserId = readVarint64(bb,
          /* unsigned */
          true);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastGiftMessageGiftImage(message) {
  let bb = popByteBuffer();

  _encodeWebcastGiftMessageGiftImage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastGiftMessageGiftImage(message, bb) {
  // optional string giftPictureUrl = 1;
  let $giftPictureUrl = message.giftPictureUrl;

  if ($giftPictureUrl !== undefined) {
    writeVarint32(bb, 10);
    writeString(bb, $giftPictureUrl);
  }
}

function decodeWebcastGiftMessageGiftImage(binary) {
  return _decodeWebcastGiftMessageGiftImage(wrapByteBuffer(binary));
}

function _decodeWebcastGiftMessageGiftImage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional string giftPictureUrl = 1;

      case 1:
        {
          message.giftPictureUrl = readString(bb, readVarint32(bb));
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastLinkMicBattle(message) {
  let bb = popByteBuffer();

  _encodeWebcastLinkMicBattle(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastLinkMicBattle(message, bb) {
  // repeated WebcastLinkMicBattleItems battleUsers = 10;
  let array$battleUsers = message.battleUsers;

  if (array$battleUsers !== undefined) {
    for (let value of array$battleUsers) {
      writeVarint32(bb, 82);
      let nested = popByteBuffer();

      _encodeWebcastLinkMicBattleItems(value, nested);

      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }
}

function decodeWebcastLinkMicBattle(binary) {
  return _decodeWebcastLinkMicBattle(wrapByteBuffer(binary));
}

function _decodeWebcastLinkMicBattle(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // repeated WebcastLinkMicBattleItems battleUsers = 10;

      case 10:
        {
          let limit = pushTemporaryLength(bb);
          let values = message.battleUsers || (message.battleUsers = []);
          values.push(_decodeWebcastLinkMicBattleItems(bb));
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastLinkMicBattleItems(message) {
  let bb = popByteBuffer();

  _encodeWebcastLinkMicBattleItems(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastLinkMicBattleItems(message, bb) {
  // optional WebcastLinkMicBattleGroup battleGroup = 2;
  let $battleGroup = message.battleGroup;

  if ($battleGroup !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeWebcastLinkMicBattleGroup($battleGroup, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeWebcastLinkMicBattleItems(binary) {
  return _decodeWebcastLinkMicBattleItems(wrapByteBuffer(binary));
}

function _decodeWebcastLinkMicBattleItems(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional WebcastLinkMicBattleGroup battleGroup = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.battleGroup = _decodeWebcastLinkMicBattleGroup(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastLinkMicBattleGroup(message) {
  let bb = popByteBuffer();

  _encodeWebcastLinkMicBattleGroup(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastLinkMicBattleGroup(message, bb) {
  // optional LinkUser user = 1;
  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 10);
    let nested = popByteBuffer();

    _encodeLinkUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeWebcastLinkMicBattleGroup(binary) {
  return _decodeWebcastLinkMicBattleGroup(wrapByteBuffer(binary));
}

function _decodeWebcastLinkMicBattleGroup(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional LinkUser user = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeLinkUser(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastLinkMicArmies(message) {
  let bb = popByteBuffer();

  _encodeWebcastLinkMicArmies(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastLinkMicArmies(message, bb) {
  // repeated WebcastLinkMicArmiesItems battleItems = 3;
  let array$battleItems = message.battleItems;

  if (array$battleItems !== undefined) {
    for (let value of array$battleItems) {
      writeVarint32(bb, 26);
      let nested = popByteBuffer();

      _encodeWebcastLinkMicArmiesItems(value, nested);

      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  } // optional int32 battleStatus = 7;


  let $battleStatus = message.battleStatus;

  if ($battleStatus !== undefined) {
    writeVarint32(bb, 56);
    writeVarint64(bb, intToLong($battleStatus));
  }
}

function decodeWebcastLinkMicArmies(binary) {
  return _decodeWebcastLinkMicArmies(wrapByteBuffer(binary));
}

function _decodeWebcastLinkMicArmies(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // repeated WebcastLinkMicArmiesItems battleItems = 3;

      case 3:
        {
          let limit = pushTemporaryLength(bb);
          let values = message.battleItems || (message.battleItems = []);
          values.push(_decodeWebcastLinkMicArmiesItems(bb));
          bb.limit = limit;
          break;
        }
      // optional int32 battleStatus = 7;

      case 7:
        {
          message.battleStatus = readVarint32(bb);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastLinkMicArmiesItems(message) {
  let bb = popByteBuffer();

  _encodeWebcastLinkMicArmiesItems(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastLinkMicArmiesItems(message, bb) {
  // optional uint64 hostUserId = 1;
  let $hostUserId = message.hostUserId;

  if ($hostUserId !== undefined) {
    writeVarint32(bb, 8);
    writeVarint64(bb, $hostUserId);
  } // repeated WebcastLinkMicArmiesGroup battleGroups = 2;


  let array$battleGroups = message.battleGroups;

  if (array$battleGroups !== undefined) {
    for (let value of array$battleGroups) {
      writeVarint32(bb, 18);
      let nested = popByteBuffer();

      _encodeWebcastLinkMicArmiesGroup(value, nested);

      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }
}

function decodeWebcastLinkMicArmiesItems(binary) {
  return _decodeWebcastLinkMicArmiesItems(wrapByteBuffer(binary));
}

function _decodeWebcastLinkMicArmiesItems(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional uint64 hostUserId = 1;

      case 1:
        {
          message.hostUserId = readVarint64(bb,
          /* unsigned */
          true);
          break;
        }
      // repeated WebcastLinkMicArmiesGroup battleGroups = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          let values = message.battleGroups || (message.battleGroups = []);
          values.push(_decodeWebcastLinkMicArmiesGroup(bb));
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastLinkMicArmiesGroup(message) {
  let bb = popByteBuffer();

  _encodeWebcastLinkMicArmiesGroup(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastLinkMicArmiesGroup(message, bb) {
  // repeated User users = 1;
  let array$users = message.users;

  if (array$users !== undefined) {
    for (let value of array$users) {
      writeVarint32(bb, 10);
      let nested = popByteBuffer();

      _encodeUser(value, nested);

      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  } // optional int32 points = 2;


  let $points = message.points;

  if ($points !== undefined) {
    writeVarint32(bb, 16);
    writeVarint64(bb, intToLong($points));
  }
}

function decodeWebcastLinkMicArmiesGroup(binary) {
  return _decodeWebcastLinkMicArmiesGroup(wrapByteBuffer(binary));
}

function _decodeWebcastLinkMicArmiesGroup(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // repeated User users = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          let values = message.users || (message.users = []);
          values.push(_decodeUser(bb));
          bb.limit = limit;
          break;
        }
      // optional int32 points = 2;

      case 2:
        {
          message.points = readVarint32(bb);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastSocialMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastSocialMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastSocialMessage(message, bb) {
  // optional WebcastMessageEvent event = 1;
  let $event = message.event;

  if ($event !== undefined) {
    writeVarint32(bb, 10);
    let nested = popByteBuffer();

    _encodeWebcastMessageEvent($event, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional User user = 2;


  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeWebcastSocialMessage(binary) {
  return _decodeWebcastSocialMessage(wrapByteBuffer(binary));
}

function _decodeWebcastSocialMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional WebcastMessageEvent event = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          message.event = _decodeWebcastMessageEvent(bb);
          bb.limit = limit;
          break;
        }
      // optional User user = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastLikeMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastLikeMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastLikeMessage(message, bb) {
  // optional WebcastMessageEvent event = 1;
  let $event = message.event;

  if ($event !== undefined) {
    writeVarint32(bb, 10);
    let nested = popByteBuffer();

    _encodeWebcastMessageEvent($event, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional User user = 5;


  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 42);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  } // optional int32 likeCount = 2;


  let $likeCount = message.likeCount;

  if ($likeCount !== undefined) {
    writeVarint32(bb, 16);
    writeVarint64(bb, intToLong($likeCount));
  } // optional int32 totalLikeCount = 3;


  let $totalLikeCount = message.totalLikeCount;

  if ($totalLikeCount !== undefined) {
    writeVarint32(bb, 24);
    writeVarint64(bb, intToLong($totalLikeCount));
  }
}

function decodeWebcastLikeMessage(binary) {
  return _decodeWebcastLikeMessage(wrapByteBuffer(binary));
}

function _decodeWebcastLikeMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional WebcastMessageEvent event = 1;

      case 1:
        {
          let limit = pushTemporaryLength(bb);
          message.event = _decodeWebcastMessageEvent(bb);
          bb.limit = limit;
          break;
        }
      // optional User user = 5;

      case 5:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }
      // optional int32 likeCount = 2;

      case 2:
        {
          message.likeCount = readVarint32(bb);
          break;
        }
      // optional int32 totalLikeCount = 3;

      case 3:
        {
          message.totalLikeCount = readVarint32(bb);
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeWebcastQuestionNewMessage(message) {
  let bb = popByteBuffer();

  _encodeWebcastQuestionNewMessage(message, bb);

  return toUint8Array(bb);
}

function _encodeWebcastQuestionNewMessage(message, bb) {
  // optional QuestionDetails questionDetails = 2;
  let $questionDetails = message.questionDetails;

  if ($questionDetails !== undefined) {
    writeVarint32(bb, 18);
    let nested = popByteBuffer();

    _encodeQuestionDetails($questionDetails, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeWebcastQuestionNewMessage(binary) {
  return _decodeWebcastQuestionNewMessage(wrapByteBuffer(binary));
}

function _decodeWebcastQuestionNewMessage(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional QuestionDetails questionDetails = 2;

      case 2:
        {
          let limit = pushTemporaryLength(bb);
          message.questionDetails = _decodeQuestionDetails(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function encodeQuestionDetails(message) {
  let bb = popByteBuffer();

  _encodeQuestionDetails(message, bb);

  return toUint8Array(bb);
}

function _encodeQuestionDetails(message, bb) {
  // optional string questionText = 2;
  let $questionText = message.questionText;

  if ($questionText !== undefined) {
    writeVarint32(bb, 18);
    writeString(bb, $questionText);
  } // optional User user = 5;


  let $user = message.user;

  if ($user !== undefined) {
    writeVarint32(bb, 42);
    let nested = popByteBuffer();

    _encodeUser($user, nested);

    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
}

function decodeQuestionDetails(binary) {
  return _decodeQuestionDetails(wrapByteBuffer(binary));
}

function _decodeQuestionDetails(bb) {
  let message = {};

  end_of_message: while (!isAtEnd(bb)) {
    let tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;
      // optional string questionText = 2;

      case 2:
        {
          message.questionText = readString(bb, readVarint32(bb));
          break;
        }
      // optional User user = 5;

      case 5:
        {
          let limit = pushTemporaryLength(bb);
          message.user = _decodeUser(bb);
          bb.limit = limit;
          break;
        }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
}

function