@chatie/grpc/dist/generated/wechaty/puppet_grpc_pb.js

gRPC for Chatie

// GENERATED CODE -- DO NOT EDIT!

// Original file comments:
// *
//
// Wechaty Puppet gRPC Protocol Buffers
//  https://github.com/chatie/grpc/
//  Huan LI <zixia@zixia.net>
//  Apr 2018
//  License: Apache-2.0
//
// Google Protocol Buffers
//  Style Guide - https://developers.google.com/protocol-buffers/docs/style
//
'use strict';
var grpc = require('grpc');
var puppet_base_pb = require('./puppet/base_pb.js');
var puppet_contact_pb = require('./puppet/contact_pb.js');
var puppet_event_pb = require('./puppet/event_pb.js');
var puppet_file_box_pb = require('./puppet/file_box_pb.js');
var puppet_friendship_pb = require('./puppet/friendship_pb.js');
var puppet_message_pb = require('./puppet/message_pb.js');
var puppet_room_pb = require('./puppet/room_pb.js');
var puppet_room_invitation_pb = require('./puppet/room_invitation_pb.js');
var puppet_room_member_pb = require('./puppet/room_member_pb.js');
var puppet_tag_pb = require('./puppet/tag_pb.js');

function serialize_wechaty_puppet_ContactAliasRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactAliasRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactAliasRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactAliasRequest(buffer_arg) {
  return puppet_contact_pb.ContactAliasRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactAliasResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactAliasResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactAliasResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactAliasResponse(buffer_arg) {
  return puppet_contact_pb.ContactAliasResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactAvatarRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactAvatarRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactAvatarRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactAvatarRequest(buffer_arg) {
  return puppet_contact_pb.ContactAvatarRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactAvatarResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactAvatarResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactAvatarResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactAvatarResponse(buffer_arg) {
  return puppet_contact_pb.ContactAvatarResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactCorporationRemarkRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactCorporationRemarkRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactCorporationRemarkRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactCorporationRemarkRequest(buffer_arg) {
  return puppet_contact_pb.ContactCorporationRemarkRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactCorporationRemarkResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactCorporationRemarkResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactCorporationRemarkResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactCorporationRemarkResponse(buffer_arg) {
  return puppet_contact_pb.ContactCorporationRemarkResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactDescriptionRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactDescriptionRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactDescriptionRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactDescriptionRequest(buffer_arg) {
  return puppet_contact_pb.ContactDescriptionRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactDescriptionResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactDescriptionResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactDescriptionResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactDescriptionResponse(buffer_arg) {
  return puppet_contact_pb.ContactDescriptionResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactListRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactListRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactListRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactListRequest(buffer_arg) {
  return puppet_contact_pb.ContactListRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactListResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactListResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactListResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactListResponse(buffer_arg) {
  return puppet_contact_pb.ContactListResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactPayloadRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactPayloadRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactPayloadRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactPayloadRequest(buffer_arg) {
  return puppet_contact_pb.ContactPayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactPayloadResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactPayloadResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactPayloadResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactPayloadResponse(buffer_arg) {
  return puppet_contact_pb.ContactPayloadResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactPhoneRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactPhoneRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactPhoneRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactPhoneRequest(buffer_arg) {
  return puppet_contact_pb.ContactPhoneRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactPhoneResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactPhoneResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactPhoneResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactPhoneResponse(buffer_arg) {
  return puppet_contact_pb.ContactPhoneResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactSelfNameRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactSelfNameRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactSelfNameRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactSelfNameRequest(buffer_arg) {
  return puppet_contact_pb.ContactSelfNameRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactSelfNameResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactSelfNameResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactSelfNameResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactSelfNameResponse(buffer_arg) {
  return puppet_contact_pb.ContactSelfNameResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactSelfQRCodeRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactSelfQRCodeRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactSelfQRCodeRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactSelfQRCodeRequest(buffer_arg) {
  return puppet_contact_pb.ContactSelfQRCodeRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactSelfQRCodeResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactSelfQRCodeResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactSelfQRCodeResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactSelfQRCodeResponse(buffer_arg) {
  return puppet_contact_pb.ContactSelfQRCodeResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactSelfSignatureRequest(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactSelfSignatureRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactSelfSignatureRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactSelfSignatureRequest(buffer_arg) {
  return puppet_contact_pb.ContactSelfSignatureRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_ContactSelfSignatureResponse(arg) {
  if (!(arg instanceof puppet_contact_pb.ContactSelfSignatureResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.ContactSelfSignatureResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_ContactSelfSignatureResponse(buffer_arg) {
  return puppet_contact_pb.ContactSelfSignatureResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_DingRequest(arg) {
  if (!(arg instanceof puppet_base_pb.DingRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.DingRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_DingRequest(buffer_arg) {
  return puppet_base_pb.DingRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_DingResponse(arg) {
  if (!(arg instanceof puppet_base_pb.DingResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.DingResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_DingResponse(buffer_arg) {
  return puppet_base_pb.DingResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_DirtyPayloadRequest(arg) {
  if (!(arg instanceof puppet_base_pb.DirtyPayloadRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.DirtyPayloadRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_DirtyPayloadRequest(buffer_arg) {
  return puppet_base_pb.DirtyPayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_DirtyPayloadResponse(arg) {
  if (!(arg instanceof puppet_base_pb.DirtyPayloadResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.DirtyPayloadResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_DirtyPayloadResponse(buffer_arg) {
  return puppet_base_pb.DirtyPayloadResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_EventRequest(arg) {
  if (!(arg instanceof puppet_event_pb.EventRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.EventRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_EventRequest(buffer_arg) {
  return puppet_event_pb.EventRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_EventResponse(arg) {
  if (!(arg instanceof puppet_event_pb.EventResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.EventResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_EventResponse(buffer_arg) {
  return puppet_event_pb.EventResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipAcceptRequest(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipAcceptRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipAcceptRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipAcceptRequest(buffer_arg) {
  return puppet_friendship_pb.FriendshipAcceptRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipAcceptResponse(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipAcceptResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipAcceptResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipAcceptResponse(buffer_arg) {
  return puppet_friendship_pb.FriendshipAcceptResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipAddRequest(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipAddRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipAddRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipAddRequest(buffer_arg) {
  return puppet_friendship_pb.FriendshipAddRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipAddResponse(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipAddResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipAddResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipAddResponse(buffer_arg) {
  return puppet_friendship_pb.FriendshipAddResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipPayloadRequest(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipPayloadRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipPayloadRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipPayloadRequest(buffer_arg) {
  return puppet_friendship_pb.FriendshipPayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipPayloadResponse(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipPayloadResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipPayloadResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipPayloadResponse(buffer_arg) {
  return puppet_friendship_pb.FriendshipPayloadResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipSearchPhoneRequest(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipSearchPhoneRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipSearchPhoneRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipSearchPhoneRequest(buffer_arg) {
  return puppet_friendship_pb.FriendshipSearchPhoneRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipSearchPhoneResponse(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipSearchPhoneResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipSearchPhoneResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipSearchPhoneResponse(buffer_arg) {
  return puppet_friendship_pb.FriendshipSearchPhoneResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipSearchWeixinRequest(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipSearchWeixinRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipSearchWeixinRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipSearchWeixinRequest(buffer_arg) {
  return puppet_friendship_pb.FriendshipSearchWeixinRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_FriendshipSearchWeixinResponse(arg) {
  if (!(arg instanceof puppet_friendship_pb.FriendshipSearchWeixinResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.FriendshipSearchWeixinResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_FriendshipSearchWeixinResponse(buffer_arg) {
  return puppet_friendship_pb.FriendshipSearchWeixinResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_LogoutRequest(arg) {
  if (!(arg instanceof puppet_base_pb.LogoutRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.LogoutRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_LogoutRequest(buffer_arg) {
  return puppet_base_pb.LogoutRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_LogoutResponse(arg) {
  if (!(arg instanceof puppet_base_pb.LogoutResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.LogoutResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_LogoutResponse(buffer_arg) {
  return puppet_base_pb.LogoutResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageContactRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageContactRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageContactRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageContactRequest(buffer_arg) {
  return puppet_message_pb.MessageContactRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageContactResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageContactResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageContactResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageContactResponse(buffer_arg) {
  return puppet_message_pb.MessageContactResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageFileRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageFileRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageFileRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageFileRequest(buffer_arg) {
  return puppet_message_pb.MessageFileRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageFileResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageFileResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageFileResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageFileResponse(buffer_arg) {
  return puppet_message_pb.MessageFileResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageFileStreamRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageFileStreamRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageFileStreamRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageFileStreamRequest(buffer_arg) {
  return puppet_message_pb.MessageFileStreamRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageFileStreamResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageFileStreamResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageFileStreamResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageFileStreamResponse(buffer_arg) {
  return puppet_message_pb.MessageFileStreamResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageImageRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageImageRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageImageRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageImageRequest(buffer_arg) {
  return puppet_message_pb.MessageImageRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageImageResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageImageResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageImageResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageImageResponse(buffer_arg) {
  return puppet_message_pb.MessageImageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageImageStreamRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageImageStreamRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageImageStreamRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageImageStreamRequest(buffer_arg) {
  return puppet_message_pb.MessageImageStreamRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageImageStreamResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageImageStreamResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageImageStreamResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageImageStreamResponse(buffer_arg) {
  return puppet_message_pb.MessageImageStreamResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageMiniProgramRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageMiniProgramRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageMiniProgramRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageMiniProgramRequest(buffer_arg) {
  return puppet_message_pb.MessageMiniProgramRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageMiniProgramResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageMiniProgramResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageMiniProgramResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageMiniProgramResponse(buffer_arg) {
  return puppet_message_pb.MessageMiniProgramResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessagePayloadRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessagePayloadRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessagePayloadRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessagePayloadRequest(buffer_arg) {
  return puppet_message_pb.MessagePayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessagePayloadResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessagePayloadResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessagePayloadResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessagePayloadResponse(buffer_arg) {
  return puppet_message_pb.MessagePayloadResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageRecallRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageRecallRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageRecallRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageRecallRequest(buffer_arg) {
  return puppet_message_pb.MessageRecallRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageRecallResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageRecallResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageRecallResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageRecallResponse(buffer_arg) {
  return puppet_message_pb.MessageRecallResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendContactRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendContactRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendContactRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendContactRequest(buffer_arg) {
  return puppet_message_pb.MessageSendContactRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendContactResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendContactResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendContactResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendContactResponse(buffer_arg) {
  return puppet_message_pb.MessageSendContactResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendFileRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendFileRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendFileRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendFileRequest(buffer_arg) {
  return puppet_message_pb.MessageSendFileRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendFileResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendFileResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendFileResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendFileResponse(buffer_arg) {
  return puppet_message_pb.MessageSendFileResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendFileStreamRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendFileStreamRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendFileStreamRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendFileStreamRequest(buffer_arg) {
  return puppet_message_pb.MessageSendFileStreamRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendFileStreamResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendFileStreamResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendFileStreamResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendFileStreamResponse(buffer_arg) {
  return puppet_message_pb.MessageSendFileStreamResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendMiniProgramRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendMiniProgramRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendMiniProgramRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendMiniProgramRequest(buffer_arg) {
  return puppet_message_pb.MessageSendMiniProgramRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendMiniProgramResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendMiniProgramResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendMiniProgramResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendMiniProgramResponse(buffer_arg) {
  return puppet_message_pb.MessageSendMiniProgramResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendTextRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendTextRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendTextRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendTextRequest(buffer_arg) {
  return puppet_message_pb.MessageSendTextRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendTextResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendTextResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendTextResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendTextResponse(buffer_arg) {
  return puppet_message_pb.MessageSendTextResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendUrlRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendUrlRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendUrlRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendUrlRequest(buffer_arg) {
  return puppet_message_pb.MessageSendUrlRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageSendUrlResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageSendUrlResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageSendUrlResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageSendUrlResponse(buffer_arg) {
  return puppet_message_pb.MessageSendUrlResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageUrlRequest(arg) {
  if (!(arg instanceof puppet_message_pb.MessageUrlRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageUrlRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageUrlRequest(buffer_arg) {
  return puppet_message_pb.MessageUrlRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_MessageUrlResponse(arg) {
  if (!(arg instanceof puppet_message_pb.MessageUrlResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.MessageUrlResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_MessageUrlResponse(buffer_arg) {
  return puppet_message_pb.MessageUrlResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomAddRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomAddRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomAddRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomAddRequest(buffer_arg) {
  return puppet_room_pb.RoomAddRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomAddResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomAddResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomAddResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomAddResponse(buffer_arg) {
  return puppet_room_pb.RoomAddResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomAnnounceRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomAnnounceRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomAnnounceRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomAnnounceRequest(buffer_arg) {
  return puppet_room_pb.RoomAnnounceRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomAnnounceResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomAnnounceResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomAnnounceResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomAnnounceResponse(buffer_arg) {
  return puppet_room_pb.RoomAnnounceResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomAvatarRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomAvatarRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomAvatarRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomAvatarRequest(buffer_arg) {
  return puppet_room_pb.RoomAvatarRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomAvatarResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomAvatarResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomAvatarResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomAvatarResponse(buffer_arg) {
  return puppet_room_pb.RoomAvatarResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomCreateRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomCreateRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomCreateRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomCreateRequest(buffer_arg) {
  return puppet_room_pb.RoomCreateRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomCreateResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomCreateResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomCreateResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomCreateResponse(buffer_arg) {
  return puppet_room_pb.RoomCreateResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomDelRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomDelRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomDelRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomDelRequest(buffer_arg) {
  return puppet_room_pb.RoomDelRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomDelResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomDelResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomDelResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomDelResponse(buffer_arg) {
  return puppet_room_pb.RoomDelResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomInvitationAcceptRequest(arg) {
  if (!(arg instanceof puppet_room_invitation_pb.RoomInvitationAcceptRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomInvitationAcceptRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomInvitationAcceptRequest(buffer_arg) {
  return puppet_room_invitation_pb.RoomInvitationAcceptRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomInvitationAcceptResponse(arg) {
  if (!(arg instanceof puppet_room_invitation_pb.RoomInvitationAcceptResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomInvitationAcceptResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomInvitationAcceptResponse(buffer_arg) {
  return puppet_room_invitation_pb.RoomInvitationAcceptResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomInvitationPayloadRequest(arg) {
  if (!(arg instanceof puppet_room_invitation_pb.RoomInvitationPayloadRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomInvitationPayloadRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomInvitationPayloadRequest(buffer_arg) {
  return puppet_room_invitation_pb.RoomInvitationPayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomInvitationPayloadResponse(arg) {
  if (!(arg instanceof puppet_room_invitation_pb.RoomInvitationPayloadResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomInvitationPayloadResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomInvitationPayloadResponse(buffer_arg) {
  return puppet_room_invitation_pb.RoomInvitationPayloadResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomListRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomListRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomListRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomListRequest(buffer_arg) {
  return puppet_room_pb.RoomListRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomListResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomListResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomListResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomListResponse(buffer_arg) {
  return puppet_room_pb.RoomListResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomMemberListRequest(arg) {
  if (!(arg instanceof puppet_room_member_pb.RoomMemberListRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomMemberListRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomMemberListRequest(buffer_arg) {
  return puppet_room_member_pb.RoomMemberListRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomMemberListResponse(arg) {
  if (!(arg instanceof puppet_room_member_pb.RoomMemberListResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomMemberListResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomMemberListResponse(buffer_arg) {
  return puppet_room_member_pb.RoomMemberListResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomMemberPayloadRequest(arg) {
  if (!(arg instanceof puppet_room_member_pb.RoomMemberPayloadRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomMemberPayloadRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomMemberPayloadRequest(buffer_arg) {
  return puppet_room_member_pb.RoomMemberPayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomMemberPayloadResponse(arg) {
  if (!(arg instanceof puppet_room_member_pb.RoomMemberPayloadResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomMemberPayloadResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomMemberPayloadResponse(buffer_arg) {
  return puppet_room_member_pb.RoomMemberPayloadResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomPayloadRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomPayloadRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomPayloadRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomPayloadRequest(buffer_arg) {
  return puppet_room_pb.RoomPayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomPayloadResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomPayloadResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomPayloadResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomPayloadResponse(buffer_arg) {
  return puppet_room_pb.RoomPayloadResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomQRCodeRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomQRCodeRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomQRCodeRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomQRCodeRequest(buffer_arg) {
  return puppet_room_pb.RoomQRCodeRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomQRCodeResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomQRCodeResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomQRCodeResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomQRCodeResponse(buffer_arg) {
  return puppet_room_pb.RoomQRCodeResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomQuitRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomQuitRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomQuitRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomQuitRequest(buffer_arg) {
  return puppet_room_pb.RoomQuitRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomQuitResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomQuitResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomQuitResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomQuitResponse(buffer_arg) {
  return puppet_room_pb.RoomQuitResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomTopicRequest(arg) {
  if (!(arg instanceof puppet_room_pb.RoomTopicRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomTopicRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomTopicRequest(buffer_arg) {
  return puppet_room_pb.RoomTopicRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_RoomTopicResponse(arg) {
  if (!(arg instanceof puppet_room_pb.RoomTopicResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.RoomTopicResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_RoomTopicResponse(buffer_arg) {
  return puppet_room_pb.RoomTopicResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_StartRequest(arg) {
  if (!(arg instanceof puppet_base_pb.StartRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.StartRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_StartRequest(buffer_arg) {
  return puppet_base_pb.StartRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_StartResponse(arg) {
  if (!(arg instanceof puppet_base_pb.StartResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.StartResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_StartResponse(buffer_arg) {
  return puppet_base_pb.StartResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_StopRequest(arg) {
  if (!(arg instanceof puppet_base_pb.StopRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.StopRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_StopRequest(buffer_arg) {
  return puppet_base_pb.StopRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_StopResponse(arg) {
  if (!(arg instanceof puppet_base_pb.StopResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.StopResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_StopResponse(buffer_arg) {
  return puppet_base_pb.StopResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactAddRequest(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactAddRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactAddRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactAddRequest(buffer_arg) {
  return puppet_tag_pb.TagContactAddRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactAddResponse(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactAddResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactAddResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactAddResponse(buffer_arg) {
  return puppet_tag_pb.TagContactAddResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactDeleteRequest(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactDeleteRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactDeleteRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactDeleteRequest(buffer_arg) {
  return puppet_tag_pb.TagContactDeleteRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactDeleteResponse(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactDeleteResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactDeleteResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactDeleteResponse(buffer_arg) {
  return puppet_tag_pb.TagContactDeleteResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactListRequest(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactListRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactListRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactListRequest(buffer_arg) {
  return puppet_tag_pb.TagContactListRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactListResponse(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactListResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactListResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactListResponse(buffer_arg) {
  return puppet_tag_pb.TagContactListResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactRemoveRequest(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactRemoveRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactRemoveRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactRemoveRequest(buffer_arg) {
  return puppet_tag_pb.TagContactRemoveRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_TagContactRemoveResponse(arg) {
  if (!(arg instanceof puppet_tag_pb.TagContactRemoveResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.TagContactRemoveResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_TagContactRemoveResponse(buffer_arg) {
  return puppet_tag_pb.TagContactRemoveResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_VersionRequest(arg) {
  if (!(arg instanceof puppet_base_pb.VersionRequest)) {
    throw new Error('Expected argument of type wechaty.puppet.VersionRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_VersionRequest(buffer_arg) {
  return puppet_base_pb.VersionRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_wechaty_puppet_VersionResponse(arg) {
  if (!(arg instanceof puppet_base_pb.VersionResponse)) {
    throw new Error('Expected argument of type wechaty.puppet.VersionResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_wechaty_puppet_VersionResponse(buffer_arg) {
  return puppet_base_pb.VersionResponse.deserializeBinary(new Uint8Array(buffer_arg));
}


var PuppetService = exports.PuppetService = {
  // *
//
// Base
//
start: {
    path: '/wechaty.Puppet/Start',
    requestStream: false,
    responseStream: false,
    requestType: puppet_base_pb.StartRequest,
    responseType: puppet_base_pb.StartResponse,
    requestSerialize: serialize_wechaty_puppet_StartRequest,
    requestDeserialize: deserialize_wechaty_puppet_StartRequest,
    responseSerialize: serialize_wechaty_puppet_StartResponse,
    responseDeserialize: deserialize_wechaty_puppet_StartResponse,
  },
  stop: {
    path: '/wechaty.Puppet/Stop',
    requestStream: false,
    responseStream: false,
    requestType: puppet_base_pb.StopRequest,
    responseType: puppet_base_pb.StopResponse,
    requestSerialize: serialize