"use strict";

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var InternalClient = require("./InternalClient.js");
var EventEmitter = require("events");

var Client = (function (_EventEmitter) {
	_inherits(Client, _EventEmitter);

	/*
 	this class is an interface for the internal
 	client.
 */

	function Client(options) {
		_classCallCheck(this, Client);

		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Client).call(this));

		_this.options = options || {};
		_this.internal = new InternalClient(_this);
		return _this;
	}

	_createClass(Client, [{
		key: "login",

		// def login
		value: function login(email, password) {
			var cb = arguments.length <= 2 || arguments[2] === undefined ? function (err, token) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.login(email, password).then(function (token) {
					cb(null, token);
					resolve(token);
				}).catch(function (e) {
					cb(e);
					reject(e);
				});
			});
		}

		// def logout

	}, {
		key: "logout",
		value: function logout() {
			var cb = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.logout().then(function () {
					cb();
					resolve();
				}).catch(function (e) {
					cb(e);
					reject(e);
				});
			});
		}
		// def sendMessage

	}, {
		key: "sendMessage",
		value: function sendMessage(where, content) {
			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {

				if (typeof options === "function") {
					// options is the callback
					callback = options;
				}

				self.internal.sendMessage(where, content, options).then(function (m) {
					callback(null, m);
					resolve(m);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def sendTTSMessage

	}, {
		key: "sendTTSMessage",
		value: function sendTTSMessage(where, content) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (e, m) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.sendMessage(where, content, { tts: true }).then(function (m) {
					callback(null, m);
					resolve(m);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}
		// def reply

	}, {
		key: "reply",
		value: function reply(where, content) {
			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {

				if (typeof options === "function") {
					// options is the callback
					callback = options;
				}

				var msg = self.internal.resolver.resolveMessage(where);
				if (msg) {
					content = msg.author + ", " + content;
					self.internal.sendMessage(msg, content, options).then(function (m) {
						callback(null, m);
						resolve(m);
					}).catch(function (e) {
						callback(e);
						reject(e);
					});
				} else {
					var err = new Error("Destination not resolvable to a message!");
					callback(err);
					reject(err);
				}
			});
		}

		// def replyTTS

	}, {
		key: "replyTTS",
		value: function replyTTS(where, content) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function () {} : arguments[2];

			return new Promise(function (resolve, reject) {
				self.reply(where, content, { tts: true }).then(function (m) {
					callback(null, m);
					resolve(m);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}
		// def deleteMessage

	}, {
		key: "deleteMessage",
		value: function deleteMessage(msg) {
			var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (e) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof options === "function") {
					// options is the callback
					callback = options;
				}

				self.internal.deleteMessage(msg, options).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}
		//def updateMessage

	}, {
		key: "updateMessage",
		value: function updateMessage(msg, content) {
			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, msg) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof options === "function") {
					// options is the callback
					callback = options;
				}

				self.internal.updateMessage(msg, content, options).then(function (msg) {
					callback(null, msg);
					resolve(msg);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def getChannelLogs

	}, {
		key: "getChannelLogs",
		value: function getChannelLogs(where) {
			var limit = arguments.length <= 1 || arguments[1] === undefined ? 500 : arguments[1];
			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, logs) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof options === "function") {
					// options is the callback
					callback = options;
				}
				self.internal.getChannelLogs(where, limit, options).then(function (logs) {
					callback(null, logs);
					resolve(logs);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def getBans

	}, {
		key: "getBans",
		value: function getBans(where) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, bans) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.getBans(where).then(function (bans) {
					callback(null, bans);
					resolve(bans);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def sendFile

	}, {
		key: "sendFile",
		value: function sendFile(where, attachment) {
			var name = arguments.length <= 2 || arguments[2] === undefined ? "image.png" : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, m) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.sendFile(where, attachment, name).then(function (m) {
					callback(null, m);
					resolve(m);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def joinServer

	}, {
		key: "joinServer",
		value: function joinServer(invite) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, srv) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.joinServer(invite).then(function (srv) {
					callback(null, srv);
					resolve(srv);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def createServer

	}, {
		key: "createServer",
		value: function createServer(name) {
			var region = arguments.length <= 1 || arguments[1] === undefined ? "london" : arguments[1];
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, srv) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.createServer(name, region).then(function (srv) {
					callback(null, srv);
					resolve(srv);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def leaveServer

	}, {
		key: "leaveServer",
		value: function leaveServer(server) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.leaveServer(server).then(function () {
					callback();resolve();
				}).catch(function (e) {
					callback(e);reject(e);
				});
			});
		}

		// def createChannel

	}, {
		key: "createChannel",
		value: function createChannel(server, name) {
			var type = arguments.length <= 2 || arguments[2] === undefined ? "text" : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, channel) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof type === "function") {
					// options is the callback
					callback = type;
				}
				self.internal.createChannel(server, name, type).then(function (channel) {
					callback(channel);resolve(channel);
				}).catch(function (e) {
					callback(e);reject(e);
				});
			});
		}

		// def deleteChannel

	}, {
		key: "deleteChannel",
		value: function deleteChannel(channel) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.deleteChannel(channel).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);reject(e);
				});
			});
		}

		//def banMember

	}, {
		key: "banMember",
		value: function banMember(user, server) {
			var length = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof length === "function") {
					// length is the callback
					callback = length;
				}
				self.internal.banMember(user, server, length).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);reject(e);
				});
			});
		}

		//def unbanMember

	}, {
		key: "unbanMember",
		value: function unbanMember(user, server) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.unbanMember(user, server).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);reject(e);
				});
			});
		}

		//def kickMember

	}, {
		key: "kickMember",
		value: function kickMember(user, server) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.kickMember(user, server).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);reject(e);
				});
			});
		}

		//def createRole

	}, {
		key: "createRole",
		value: function createRole(server) {
			var data = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, res) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof data === "function") {
					// data is the callback
					callback = data;
				}
				self.internal.createRole(server, data).then(function (role) {
					callback(null, role);
					resolve(role);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def updateRole

	}, {
		key: "updateRole",
		value: function updateRole(role) {
			var data = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, res) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof data === "function") {
					// data is the callback
					callback = data;
				}
				self.internal.updateRole(role, data).then(function (role) {
					callback(null, role);
					resolve(role);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def deleteRole

	}, {
		key: "deleteRole",
		value: function deleteRole(role) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.deleteRole(role).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def addMemberToRole

	}, {
		key: "addMemberToRole",
		value: function addMemberToRole(member, role) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.addMemberToRole(member, role).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def addUserToRole

	}, {
		key: "addUserToRole",
		value: function addUserToRole(member, role) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			return this.addMemberToRole(member, role, callback);
		}

		// def removeMemberFromRole

	}, {
		key: "removeMemberFromRole",
		value: function removeMemberFromRole(member, role) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.removeMemberFromRole(member, role).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def removeUserFromRole

	}, {
		key: "removeUserFromRole",
		value: function removeUserFromRole(member, role) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			return this.removeUserFromRole(member, role, callback);
		}

		// def createInvite

	}, {
		key: "createInvite",
		value: function createInvite(chanServ, options) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, invite) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof options === "function") {
					// length is the callback
					callback = options;
				}

				self.internal.createInvite(chanServ, options).then(function (invite) {
					callback(null, invite);
					resolve(invite);
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def deleteInvite

	}, {
		key: "deleteInvite",
		value: function deleteInvite(invite) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.deleteInvite(invite).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def overwritePermissions

	}, {
		key: "overwritePermissions",
		value: function overwritePermissions(channel, role) {
			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.overwritePermissions(channel, role, options).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def setStatus

	}, {
		key: "setStatus",
		value: function setStatus(idleStatus, gameID) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {
				if (typeof gameID === "function") {
					// gameID is the callback
					callback = gameID;
				} else if (typeof idleStatus === "function") {
					// idleStatus is the callback
					callback = idleStatus;
				}

				self.internal.setStatus(idleStatus, gameID).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def sendTyping

	}, {
		key: "sendTyping",
		value: function sendTyping(channel) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.sendTyping(channel).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		// def setTopic

	}, {
		key: "setTopic",
		value: function setTopic(channel, topic) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.setTopic(channel, topic).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def setChannelName

	}, {
		key: "setChannelName",
		value: function setChannelName(channel, name) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.setChannelName(channel, name).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def setChannelNameAndTopic

	}, {
		key: "setChannelNameAndTopic",
		value: function setChannelNameAndTopic(channel, name, topic) {
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err) {} : arguments[3];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.setChannelNameAndTopic(channel, name, topic).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def updateChannel

	}, {
		key: "updateChannel",
		value: function updateChannel(channel, data) {
			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.updateChannel(channel, data).then(function () {
					callback();
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def startTyping

	}, {
		key: "startTyping",
		value: function startTyping(channel) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.startTyping(channel).then(function () {
					callback(null);
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def stopTyping

	}, {
		key: "stopTyping",
		value: function stopTyping(channel) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.stopTyping(channel).then(function () {
					callback(null);
					resolve();
				}).catch(function (e) {
					callback(e);
					reject(e);
				});
			});
		}

		//def updateDetails

	}, {
		key: "updateDetails",
		value: function updateDetails(details) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.updateDetails(details).then(function () {
					callback();
					resolve();
				}).catch(function (err) {
					callback(err);
					reject(err);
				});
			});
		}

		//def setUsername

	}, {
		key: "setUsername",
		value: function setUsername(name) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.setUsername(name).then(function () {
					callback();
					resolve();
				}).catch(function (err) {
					callback(err);
					reject(err);
				});
			});
		}

		//def setAvatar

	}, {
		key: "setAvatar",
		value: function setAvatar(avatar) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.setAvatar(avatar).then(function () {
					callback();
					resolve();
				}).catch(function (err) {
					callback(err);
					reject(err);
				});
			});
		}

		//def joinVoiceChannel

	}, {
		key: "joinVoiceChannel",
		value: function joinVoiceChannel(channel) {
			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];

			var self = this;
			return new Promise(function (resolve, reject) {

				self.internal.joinVoiceChannel(channel).then(function (chan) {
					callback(null, chan);
					resolve(chan);
				}).catch(function (err) {
					callback(err);
					reject(err);
				});
			});
		}

		// def leaveVoiceChannel

	}, {
		key: "leaveVoiceChannel",
		value: function leaveVoiceChannel() {
			var callback = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];

			var self = this;
			return new Promise(function (resolve, reject) {
				self.internal.leaveVoiceChannel().then(function () {
					callback();
					resolve();
				}).catch(function (err) {
					callback(err);
					reject(err);
				});
			});
		}

		// def awaitResponse

	}, {
		key: "awaitResponse",
		value: function awaitResponse(msg) {
			var toSend = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];

			var _this2 = this;

			var options = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];
			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, newMsg) {} : arguments[3];

			var self = this;

			return new Promise(function (resolve, reject) {

				function error(e) {
					callback(e);
					reject(e);
				}

				if (toSend) {
					if (typeof toSend === "function") {
						// (msg, callback)
						callback = toSend;
						final();
					} else {
						// (msg, toSend, ...)
						if (options) {
							if (typeof options === "function") {
								//(msg, toSend, callback)
								callback = options;
								_this2.sendMessage(msg, toSend).then(final).catch(error);
							} else {
								//(msg, toSend, options, callback)
								_this2.sendMessage(msg, toSend, options).then(final).catch(error);
							}
						} else {
							// (msg, toSend) promise
							_this2.sendMessage(msg, toSend).then(final).catch(error);
						}
					}
				} else {
					// (msg) promise
					final();
				}

				function final() {
					self.internal.awaitResponse(msg).then(function (newMsg) {
						resolve(newMsg);
						callback(null, newMsg);
					}).catch(error);
				}
			});
		}
	}, {
		key: "setStatusIdle",
		value: function setStatusIdle() {
			this.setStatus("idle");
		}
	}, {
		key: "setStatusOnline",
		value: function setStatusOnline() {
			var cb = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];

			this.setStatus("online");
		}
	}, {
		key: "setStatusActive",
		value: function setStatusActive() {
			this.setStatusOnline();
		}
	}, {
		key: "setStatusHere",
		value: function setStatusHere() {
			this.setStatusOnline();
		}
	}, {
		key: "setStatusAvailable",
		value: function setStatusAvailable() {
			this.setStatusOnline();
		}
	}, {
		key: "setStatusAway",
		value: function setStatusAway() {
			this.setStatusIdle();
		}
	}, {
		key: "setPlayingGame",
		value: function setPlayingGame(game) {
			this.setStatus(null, game);
		}
	}, {
		key: "users",
		get: function get() {
			return this.internal.users;
		}
	}, {
		key: "channels",
		get: function get() {
			return this.internal.channels;
		}
	}, {
		key: "servers",
		get: function get() {
			return this.internal.servers;
		}
	}, {
		key: "privateChannels",
		get: function get() {
			return this.internal.private_channels;
		}
	}, {
		key: "voiceConnection",
		get: function get() {
			return this.internal.voiceConnection;
		}
	}, {
		key: "readyTime",
		get: function get() {
			return this.internal.readyTime;
		}
	}, {
		key: "uptime",
		get: function get() {
			return this.internal.uptime;
		}
	}, {
		key: "user",
		get: function get() {
			return this.internal.user;
		}
	}]);

	return Client;
})(EventEmitter);

module.exports = Client;