@juzi/wechaty-grpc 1.0.0

package/dist/cjs/out/wechaty/puppet_pb_service.js

@@ -0,0 +1,2524 @@
+// package: wechaty
+// file: wechaty/puppet.proto
+
+var wechaty_puppet_pb = require("../wechaty/puppet_pb");
+var wechaty_deprecated_file_box_pb = require("../wechaty/deprecated/file-box_pb");
+var wechaty_puppet_base_pb = require("../wechaty/puppet/base_pb");
+var wechaty_puppet_contact_pb = require("../wechaty/puppet/contact_pb");
+var wechaty_puppet_download_upload_pb = require("../wechaty/puppet/download-upload_pb");
+var wechaty_puppet_event_pb = require("../wechaty/puppet/event_pb");
+var wechaty_puppet_friendship_pb = require("../wechaty/puppet/friendship_pb");
+var wechaty_puppet_message_pb = require("../wechaty/puppet/message_pb");
+var wechaty_puppet_room_invitation_pb = require("../wechaty/puppet/room-invitation_pb");
+var wechaty_puppet_room_member_pb = require("../wechaty/puppet/room-member_pb");
+var wechaty_puppet_room_pb = require("../wechaty/puppet/room_pb");
+var wechaty_puppet_tag_pb = require("../wechaty/puppet/tag_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var Puppet = (function () {
+  function Puppet() {}
+  Puppet.serviceName = "wechaty.Puppet";
+  return Puppet;
+}());
+
+Puppet.MessageFileStream = {
+  methodName: "MessageFileStream",
+  service: Puppet,
+  requestStream: false,
+  responseStream: true,
+  requestType: wechaty_deprecated_file_box_pb.MessageFileStreamRequest,
+  responseType: wechaty_deprecated_file_box_pb.MessageFileStreamResponse
+};
+
+Puppet.MessageImageStream = {
+  methodName: "MessageImageStream",
+  service: Puppet,
+  requestStream: false,
+  responseStream: true,
+  requestType: wechaty_deprecated_file_box_pb.MessageImageStreamRequest,
+  responseType: wechaty_deprecated_file_box_pb.MessageImageStreamResponse
+};
+
+Puppet.MessageSendFileStream = {
+  methodName: "MessageSendFileStream",
+  service: Puppet,
+  requestStream: true,
+  responseStream: false,
+  requestType: wechaty_deprecated_file_box_pb.MessageSendFileStreamRequest,
+  responseType: wechaty_deprecated_file_box_pb.MessageSendFileStreamResponse
+};
+
+Puppet.Start = {
+  methodName: "Start",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_base_pb.StartRequest,
+  responseType: wechaty_puppet_base_pb.StartResponse
+};
+
+Puppet.Stop = {
+  methodName: "Stop",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_base_pb.StopRequest,
+  responseType: wechaty_puppet_base_pb.StopResponse
+};
+
+Puppet.Logout = {
+  methodName: "Logout",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_base_pb.LogoutRequest,
+  responseType: wechaty_puppet_base_pb.LogoutResponse
+};
+
+Puppet.Ding = {
+  methodName: "Ding",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_base_pb.DingRequest,
+  responseType: wechaty_puppet_base_pb.DingResponse
+};
+
+Puppet.Version = {
+  methodName: "Version",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_base_pb.VersionRequest,
+  responseType: wechaty_puppet_base_pb.VersionResponse
+};
+
+Puppet.Event = {
+  methodName: "Event",
+  service: Puppet,
+  requestStream: false,
+  responseStream: true,
+  requestType: wechaty_puppet_event_pb.EventRequest,
+  responseType: wechaty_puppet_event_pb.EventResponse
+};
+
+Puppet.DirtyPayload = {
+  methodName: "DirtyPayload",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_base_pb.DirtyPayloadRequest,
+  responseType: wechaty_puppet_base_pb.DirtyPayloadResponse
+};
+
+Puppet.ContactSelfQRCode = {
+  methodName: "ContactSelfQRCode",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactSelfQRCodeRequest,
+  responseType: wechaty_puppet_contact_pb.ContactSelfQRCodeResponse
+};
+
+Puppet.ContactSelfName = {
+  methodName: "ContactSelfName",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactSelfNameRequest,
+  responseType: wechaty_puppet_contact_pb.ContactSelfNameResponse
+};
+
+Puppet.ContactSelfSignature = {
+  methodName: "ContactSelfSignature",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactSelfSignatureRequest,
+  responseType: wechaty_puppet_contact_pb.ContactSelfSignatureResponse
+};
+
+Puppet.ContactPayload = {
+  methodName: "ContactPayload",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactPayloadRequest,
+  responseType: wechaty_puppet_contact_pb.ContactPayloadResponse
+};
+
+Puppet.ContactAlias = {
+  methodName: "ContactAlias",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactAliasRequest,
+  responseType: wechaty_puppet_contact_pb.ContactAliasResponse
+};
+
+Puppet.ContactAvatar = {
+  methodName: "ContactAvatar",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactAvatarRequest,
+  responseType: wechaty_puppet_contact_pb.ContactAvatarResponse
+};
+
+Puppet.ContactPhone = {
+  methodName: "ContactPhone",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactPhoneRequest,
+  responseType: wechaty_puppet_contact_pb.ContactPhoneResponse
+};
+
+Puppet.ContactCorporationRemark = {
+  methodName: "ContactCorporationRemark",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactCorporationRemarkRequest,
+  responseType: wechaty_puppet_contact_pb.ContactCorporationRemarkResponse
+};
+
+Puppet.ContactDescription = {
+  methodName: "ContactDescription",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactDescriptionRequest,
+  responseType: wechaty_puppet_contact_pb.ContactDescriptionResponse
+};
+
+Puppet.ContactList = {
+  methodName: "ContactList",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_contact_pb.ContactListRequest,
+  responseType: wechaty_puppet_contact_pb.ContactListResponse
+};
+
+Puppet.FriendshipPayload = {
+  methodName: "FriendshipPayload",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_friendship_pb.FriendshipPayloadRequest,
+  responseType: wechaty_puppet_friendship_pb.FriendshipPayloadResponse
+};
+
+Puppet.FriendshipSearchPhone = {
+  methodName: "FriendshipSearchPhone",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_friendship_pb.FriendshipSearchPhoneRequest,
+  responseType: wechaty_puppet_friendship_pb.FriendshipSearchPhoneResponse
+};
+
+Puppet.FriendshipSearchWeixin = {
+  methodName: "FriendshipSearchWeixin",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_friendship_pb.FriendshipSearchHandleRequest,
+  responseType: wechaty_puppet_friendship_pb.FriendshipSearchHandleResponse
+};
+
+Puppet.FriendshipSearchHandle = {
+  methodName: "FriendshipSearchHandle",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_friendship_pb.FriendshipSearchHandleRequest,
+  responseType: wechaty_puppet_friendship_pb.FriendshipSearchHandleResponse
+};
+
+Puppet.FriendshipAdd = {
+  methodName: "FriendshipAdd",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_friendship_pb.FriendshipAddRequest,
+  responseType: wechaty_puppet_friendship_pb.FriendshipAddResponse
+};
+
+Puppet.FriendshipAccept = {
+  methodName: "FriendshipAccept",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_friendship_pb.FriendshipAcceptRequest,
+  responseType: wechaty_puppet_friendship_pb.FriendshipAcceptResponse
+};
+
+Puppet.MessageFile = {
+  methodName: "MessageFile",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageFileRequest,
+  responseType: wechaty_puppet_message_pb.MessageFileResponse
+};
+
+Puppet.MessageImage = {
+  methodName: "MessageImage",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageImageRequest,
+  responseType: wechaty_puppet_message_pb.MessageImageResponse
+};
+
+Puppet.MessageSendFile = {
+  methodName: "MessageSendFile",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageSendFileRequest,
+  responseType: wechaty_puppet_message_pb.MessageSendFileResponse
+};
+
+Puppet.MessagePayload = {
+  methodName: "MessagePayload",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessagePayloadRequest,
+  responseType: wechaty_puppet_message_pb.MessagePayloadResponse
+};
+
+Puppet.MessageContact = {
+  methodName: "MessageContact",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageContactRequest,
+  responseType: wechaty_puppet_message_pb.MessageContactResponse
+};
+
+Puppet.MessageMiniProgram = {
+  methodName: "MessageMiniProgram",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageMiniProgramRequest,
+  responseType: wechaty_puppet_message_pb.MessageMiniProgramResponse
+};
+
+Puppet.MessageUrl = {
+  methodName: "MessageUrl",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageUrlRequest,
+  responseType: wechaty_puppet_message_pb.MessageUrlResponse
+};
+
+Puppet.MessageRecall = {
+  methodName: "MessageRecall",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageRecallRequest,
+  responseType: wechaty_puppet_message_pb.MessageRecallResponse
+};
+
+Puppet.MessageForward = {
+  methodName: "MessageForward",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageForwardRequest,
+  responseType: wechaty_puppet_message_pb.MessageForwardResponse
+};
+
+Puppet.MessageLocation = {
+  methodName: "MessageLocation",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageLocationRequest,
+  responseType: wechaty_puppet_message_pb.MessageLocationResponse
+};
+
+Puppet.MessageSendContact = {
+  methodName: "MessageSendContact",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageSendContactRequest,
+  responseType: wechaty_puppet_message_pb.MessageSendContactResponse
+};
+
+Puppet.MessageSendText = {
+  methodName: "MessageSendText",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageSendTextRequest,
+  responseType: wechaty_puppet_message_pb.MessageSendTextResponse
+};
+
+Puppet.MessageSendMiniProgram = {
+  methodName: "MessageSendMiniProgram",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageSendMiniProgramRequest,
+  responseType: wechaty_puppet_message_pb.MessageSendMiniProgramResponse
+};
+
+Puppet.MessageSendUrl = {
+  methodName: "MessageSendUrl",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageSendUrlRequest,
+  responseType: wechaty_puppet_message_pb.MessageSendUrlResponse
+};
+
+Puppet.MessageSendLocation = {
+  methodName: "MessageSendLocation",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_message_pb.MessageSendLocationRequest,
+  responseType: wechaty_puppet_message_pb.MessageSendLocationResponse
+};
+
+Puppet.RoomPayload = {
+  methodName: "RoomPayload",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomPayloadRequest,
+  responseType: wechaty_puppet_room_pb.RoomPayloadResponse
+};
+
+Puppet.RoomList = {
+  methodName: "RoomList",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomListRequest,
+  responseType: wechaty_puppet_room_pb.RoomListResponse
+};
+
+Puppet.RoomAdd = {
+  methodName: "RoomAdd",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomAddRequest,
+  responseType: wechaty_puppet_room_pb.RoomAddResponse
+};
+
+Puppet.RoomAvatar = {
+  methodName: "RoomAvatar",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomAvatarRequest,
+  responseType: wechaty_puppet_room_pb.RoomAvatarResponse
+};
+
+Puppet.RoomCreate = {
+  methodName: "RoomCreate",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomCreateRequest,
+  responseType: wechaty_puppet_room_pb.RoomCreateResponse
+};
+
+Puppet.RoomDel = {
+  methodName: "RoomDel",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomDelRequest,
+  responseType: wechaty_puppet_room_pb.RoomDelResponse
+};
+
+Puppet.RoomQuit = {
+  methodName: "RoomQuit",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomQuitRequest,
+  responseType: wechaty_puppet_room_pb.RoomQuitResponse
+};
+
+Puppet.RoomTopic = {
+  methodName: "RoomTopic",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomTopicRequest,
+  responseType: wechaty_puppet_room_pb.RoomTopicResponse
+};
+
+Puppet.RoomQRCode = {
+  methodName: "RoomQRCode",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomQRCodeRequest,
+  responseType: wechaty_puppet_room_pb.RoomQRCodeResponse
+};
+
+Puppet.RoomAnnounce = {
+  methodName: "RoomAnnounce",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_pb.RoomAnnounceRequest,
+  responseType: wechaty_puppet_room_pb.RoomAnnounceResponse
+};
+
+Puppet.RoomMemberPayload = {
+  methodName: "RoomMemberPayload",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_member_pb.RoomMemberPayloadRequest,
+  responseType: wechaty_puppet_room_member_pb.RoomMemberPayloadResponse
+};
+
+Puppet.RoomMemberList = {
+  methodName: "RoomMemberList",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_member_pb.RoomMemberListRequest,
+  responseType: wechaty_puppet_room_member_pb.RoomMemberListResponse
+};
+
+Puppet.RoomInvitationPayload = {
+  methodName: "RoomInvitationPayload",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_invitation_pb.RoomInvitationPayloadRequest,
+  responseType: wechaty_puppet_room_invitation_pb.RoomInvitationPayloadResponse
+};
+
+Puppet.RoomInvitationAccept = {
+  methodName: "RoomInvitationAccept",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_room_invitation_pb.RoomInvitationAcceptRequest,
+  responseType: wechaty_puppet_room_invitation_pb.RoomInvitationAcceptResponse
+};
+
+Puppet.TagContactAdd = {
+  methodName: "TagContactAdd",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_tag_pb.TagContactAddRequest,
+  responseType: wechaty_puppet_tag_pb.TagContactAddResponse
+};
+
+Puppet.TagContactRemove = {
+  methodName: "TagContactRemove",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_tag_pb.TagContactRemoveRequest,
+  responseType: wechaty_puppet_tag_pb.TagContactRemoveResponse
+};
+
+Puppet.TagContactDelete = {
+  methodName: "TagContactDelete",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_tag_pb.TagContactDeleteRequest,
+  responseType: wechaty_puppet_tag_pb.TagContactDeleteResponse
+};
+
+Puppet.TagContactList = {
+  methodName: "TagContactList",
+  service: Puppet,
+  requestStream: false,
+  responseStream: false,
+  requestType: wechaty_puppet_tag_pb.TagContactListRequest,
+  responseType: wechaty_puppet_tag_pb.TagContactListResponse
+};
+
+Puppet.Download = {
+  methodName: "Download",
+  service: Puppet,
+  requestStream: false,
+  responseStream: true,
+  requestType: wechaty_puppet_download_upload_pb.DownloadRequest,
+  responseType: wechaty_puppet_download_upload_pb.DownloadResponse
+};
+
+Puppet.Upload = {
+  methodName: "Upload",
+  service: Puppet,
+  requestStream: true,
+  responseStream: false,
+  requestType: wechaty_puppet_download_upload_pb.UploadRequest,
+  responseType: wechaty_puppet_download_upload_pb.UploadResponse
+};
+
+exports.Puppet = Puppet;
+
+function PuppetClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+PuppetClient.prototype.messageFileStream = function messageFileStream(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(Puppet.MessageFileStream, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageImageStream = function messageImageStream(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(Puppet.MessageImageStream, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageSendFileStream = function messageSendFileStream(metadata) {
+  var listeners = {
+    end: [],
+    status: []
+  };
+  var client = grpc.client(Puppet.MessageSendFileStream, {
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport
+  });
+  client.onEnd(function (status, statusMessage, trailers) {
+    listeners.status.forEach(function (handler) {
+      handler({ code: status, details: statusMessage, metadata: trailers });
+    });
+    listeners.end.forEach(function (handler) {
+      handler({ code: status, details: statusMessage, metadata: trailers });
+    });
+    listeners = null;
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    write: function (requestMessage) {
+      if (!client.started) {
+        client.start(metadata);
+      }
+      client.send(requestMessage);
+      return this;
+    },
+    end: function () {
+      client.finishSend();
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.start = function start(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.Start, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.stop = function stop(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.Stop, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.logout = function logout(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.Logout, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.ding = function ding(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.Ding, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.version = function version(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.Version, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.event = function event(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(Puppet.Event, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.dirtyPayload = function dirtyPayload(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.DirtyPayload, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactSelfQRCode = function contactSelfQRCode(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactSelfQRCode, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactSelfName = function contactSelfName(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactSelfName, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactSelfSignature = function contactSelfSignature(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactSelfSignature, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactPayload = function contactPayload(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactPayload, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactAlias = function contactAlias(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactAlias, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactAvatar = function contactAvatar(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactAvatar, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactPhone = function contactPhone(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactPhone, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactCorporationRemark = function contactCorporationRemark(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactCorporationRemark, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactDescription = function contactDescription(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactDescription, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.contactList = function contactList(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.ContactList, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.friendshipPayload = function friendshipPayload(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.FriendshipPayload, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.friendshipSearchPhone = function friendshipSearchPhone(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.FriendshipSearchPhone, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.friendshipSearchWeixin = function friendshipSearchWeixin(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.FriendshipSearchWeixin, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.friendshipSearchHandle = function friendshipSearchHandle(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.FriendshipSearchHandle, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.friendshipAdd = function friendshipAdd(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.FriendshipAdd, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.friendshipAccept = function friendshipAccept(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.FriendshipAccept, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageFile = function messageFile(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageFile, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageImage = function messageImage(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageImage, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageSendFile = function messageSendFile(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageSendFile, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messagePayload = function messagePayload(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessagePayload, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageContact = function messageContact(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageContact, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageMiniProgram = function messageMiniProgram(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageMiniProgram, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageUrl = function messageUrl(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageUrl, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageRecall = function messageRecall(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageRecall, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageForward = function messageForward(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageForward, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageLocation = function messageLocation(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageLocation, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageSendContact = function messageSendContact(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageSendContact, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageSendText = function messageSendText(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageSendText, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageSendMiniProgram = function messageSendMiniProgram(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageSendMiniProgram, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageSendUrl = function messageSendUrl(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageSendUrl, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.messageSendLocation = function messageSendLocation(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.MessageSendLocation, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomPayload = function roomPayload(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomPayload, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomList = function roomList(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomList, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomAdd = function roomAdd(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomAdd, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomAvatar = function roomAvatar(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomAvatar, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomCreate = function roomCreate(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomCreate, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomDel = function roomDel(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomDel, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomQuit = function roomQuit(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomQuit, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomTopic = function roomTopic(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomTopic, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomQRCode = function roomQRCode(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomQRCode, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomAnnounce = function roomAnnounce(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomAnnounce, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomMemberPayload = function roomMemberPayload(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomMemberPayload, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomMemberList = function roomMemberList(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomMemberList, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomInvitationPayload = function roomInvitationPayload(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomInvitationPayload, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.roomInvitationAccept = function roomInvitationAccept(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.RoomInvitationAccept, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.tagContactAdd = function tagContactAdd(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.TagContactAdd, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.tagContactRemove = function tagContactRemove(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.TagContactRemove, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.tagContactDelete = function tagContactDelete(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.TagContactDelete, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.tagContactList = function tagContactList(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Puppet.TagContactList, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.download = function download(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(Puppet.Download, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+PuppetClient.prototype.upload = function upload(metadata) {
+  var listeners = {
+    end: [],
+    status: []
+  };
+  var client = grpc.client(Puppet.Upload, {
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport
+  });
+  client.onEnd(function (status, statusMessage, trailers) {
+    listeners.status.forEach(function (handler) {
+      handler({ code: status, details: statusMessage, metadata: trailers });
+    });
+    listeners.end.forEach(function (handler) {
+      handler({ code: status, details: statusMessage, metadata: trailers });
+    });
+    listeners = null;
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    write: function (requestMessage) {
+      if (!client.started) {
+        client.start(metadata);
+      }
+      client.send(requestMessage);
+      return this;
+    },
+    end: function () {
+      client.finishSend();
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+exports.PuppetClient = PuppetClient;
+