Folder turned necessary after Discord debate

lib/Structures/Channel.js

@@ -0,0 +1,45 @@
+"use strict";
+
+exports.__esModule = true;
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _UtilEquality = require("../Util/Equality");
+
+var _UtilEquality2 = _interopRequireDefault(_UtilEquality);
+
+var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser");
+
+var Channel = (function (_Equality) {
+	_inherits(Channel, _Equality);
+
+	function Channel(data, client) {
+		_classCallCheck(this, Channel);
+
+		_Equality.call(this);
+		this.id = data.id;
+		this.client = client;
+	}
+
+	Channel.prototype["delete"] = function _delete() {
+		return this.client.deleteChannel.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	_createClass(Channel, [{
+		key: "isPrivate",
+		get: function get() {
+			return !!this.server;
+		}
+	}]);
+
+	return Channel;
+})(_UtilEquality2["default"]);
+
+exports["default"] = Channel;
+module.exports = exports["default"];

lib/Structures/ChannelPermissions.js

@@ -0,0 +1,78 @@
+"use strict";
+
+exports.__esModule = true;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _Constants = require("../Constants");
+
+var ChannelPermissions = (function () {
+	function ChannelPermissions(permissions) {
+		_classCallCheck(this, ChannelPermissions);
+
+		this.permissions = permissions;
+	}
+
+	ChannelPermissions.prototype.serialise = function serialise(explicit) {
+		var _this = this;
+
+		var hp = function hp(perm) {
+			return _this.hasPermission(perm, explicit);
+		};
+
+		return {
+			// general
+			createInstantInvite: hp(_Constants.Permissions.createInstantInvite),
+			kickMembers: hp(_Constants.Permissions.kickMembers),
+			banMembers: hp(_Constants.Permissions.banMembers),
+			managePermissions: hp(_Constants.Permissions.managePermissions),
+			manageChannel: hp(_Constants.Permissions.manageChannel),
+			manageServer: hp(_Constants.Permissions.manageServer),
+			// text
+			readMessages: hp(_Constants.Permissions.readMessages),
+			sendMessages: hp(_Constants.Permissions.sendMessages),
+			sendTTSMessages: hp(_Constants.Permissions.sendTTSMessages),
+			manageMessages: hp(_Constants.Permissions.manageMessages),
+			embedLinks: hp(_Constants.Permissions.embedLinks),
+			attachFiles: hp(_Constants.Permissions.attachFiles),
+			readMessageHistory: hp(_Constants.Permissions.readMessageHistory),
+			mentionEveryone: hp(_Constants.Permissions.mentionEveryone),
+			// voice
+			voiceConnect: hp(_Constants.Permissions.voiceConnect),
+			voiceSpeak: hp(_Constants.Permissions.voiceSpeak),
+			voiceMuteMembers: hp(_Constants.Permissions.voiceMuteMembers),
+			voiceDeafenMembers: hp(_Constants.Permissions.voiceDeafenMembers),
+			voiceMoveMembers: hp(_Constants.Permissions.voiceMoveMembers),
+			voiceUseVAD: hp(_Constants.Permissions.voiceUseVAD)
+		};
+	};
+
+	ChannelPermissions.prototype.serialize = function serialize() {
+		// ;n;
+		return this.serialise();
+	};
+
+	ChannelPermissions.prototype.hasPermission = function hasPermission(perm) {
+		var explicit = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
+
+		if (perm instanceof String || typeof perm === "string") {
+			perm = _Constants.Permissions[perm];
+		}
+		if (!perm) {
+			return false;
+		}
+		if (!explicit) {
+			// implicit permissions allowed
+			if (!!(this.permissions & _Constants.Permissions.manageRoles)) {
+				// manageRoles allowed, they have all permissions
+				return true;
+			}
+		}
+		return !!(this.permissions & perm);
+	};
+
+	return ChannelPermissions;
+})();
+
+exports["default"] = ChannelPermissions;
+module.exports = exports["default"];

lib/Structures/Invite.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Invite = (function () {
+      function Invite(data, chan, client) {
+            _classCallCheck(this, Invite);
+
+            this.maxAge = data.max_age;
+            this.code = data.code;
+            this.server = chan.server;
+            this.channel = chan;
+            this.revoked = data.revoked;
+            this.createdAt = Date.parse(data.created_at);
+            this.temporary = data.temporary;
+            this.uses = data.uses;
+            this.maxUses = data.uses;
+            this.inviter = client.internal.users.get("id", data.inviter.id);
+            this.xkcd = data.xkcdpass;
+      }
+
+      Invite.prototype.toString = function toString() {
+            return "https://discord.gg/" + this.code;
+      };
+
+      return Invite;
+})();
+
+exports["default"] = Invite;
+module.exports = exports["default"];

lib/Structures/Message.js

@@ -0,0 +1,101 @@
+"use strict";
+
+exports.__esModule = true;
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _UtilCache = require("../Util/Cache");
+
+var _UtilCache2 = _interopRequireDefault(_UtilCache);
+
+var _User = require("./User");
+
+var _User2 = _interopRequireDefault(_User);
+
+var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser");
+
+var _UtilEquality = require("../Util/Equality");
+
+var _UtilEquality2 = _interopRequireDefault(_UtilEquality);
+
+var Message = (function (_Equality) {
+	_inherits(Message, _Equality);
+
+	function Message(data, channel, client) {
+		var _this = this;
+
+		_classCallCheck(this, Message);
+
+		_Equality.call(this);
+		this.channel = channel;
+		this.client = client;
+		this.nonce = data.nonce;
+		this.attachments = data.attachments;
+		this.tts = data.tts;
+		this.embeds = data.embeds;
+		this.timestamp = Date.parse(data.timestamp);
+		this.everyoneMentioned = data.mention_everyone;
+		this.id = data.id;
+
+		if (data.edited_timestamp) this.editedTimestamp = Date.parse(data.edited_timestamp);
+
+		if (data.author instanceof _User2["default"]) this.author = data.author;else this.author = client.internal.users.add(new _User2["default"](data.author, client));
+
+		this.content = data.content;
+		this.mentions = new _UtilCache2["default"]();
+
+		data.mentions.forEach(function (mention) {
+			// this is .add and not .get because it allows the bot to cache
+			// users from messages from logs who may have left the server and were
+			// not previously cached.
+			if (mention instanceof _User2["default"]) _this.mentions.push(mention);else _this.mentions.add(client.internal.users.add(new _User2["default"](mention, client)));
+		});
+	}
+
+	Message.prototype.isMentioned = function isMentioned(user) {
+		user = this.client.internal.resolver.resolveUser(user);
+		if (user) {
+			return this.mentions.has("id", user.id);
+		} else {
+			return false;
+		}
+	};
+
+	Message.prototype.toString = function toString() {
+		return this.content;
+	};
+
+	Message.prototype["delete"] = function _delete() {
+		return this.client.deleteMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	Message.prototype.update = function update() {
+		return this.client.updateMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	Message.prototype.reply = function reply() {
+		return this.client.reply.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	Message.prototype.replyTTS = function replyTTS() {
+		return this.client.replyTTS.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	_createClass(Message, [{
+		key: "sender",
+		get: function get() {
+			return this.author;
+		}
+	}]);
+
+	return Message;
+})(_UtilEquality2["default"]);
+
+exports["default"] = Message;
+module.exports = exports["default"];

lib/Structures/PMChannel.js

@@ -0,0 +1,66 @@
+"use strict";
+
+exports.__esModule = true;
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _Channel2 = require("./Channel");
+
+var _Channel3 = _interopRequireDefault(_Channel2);
+
+var _User = require("./User");
+
+var _User2 = _interopRequireDefault(_User);
+
+var _UtilCache = require("../Util/Cache");
+
+var _UtilCache2 = _interopRequireDefault(_UtilCache);
+
+var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser");
+
+var PMChannel = (function (_Channel) {
+	_inherits(PMChannel, _Channel);
+
+	function PMChannel(data, client) {
+		_classCallCheck(this, PMChannel);
+
+		_Channel.call(this, data, client);
+
+		this.type = data.type || "text";
+		this.lastMessageId = data.last_message_id;
+		this.messages = new _UtilCache2["default"]("id", 1000);
+		this.recipient = this.client.internal.users.add(new _User2["default"](data.recipient, this.client));
+	}
+
+	/* warning! may return null */
+
+	PMChannel.prototype.toString = function toString() {
+		return this.recipient.toString();
+	};
+
+	PMChannel.prototype.sendMessage = function sendMessage() {
+		return this.client.sendMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	PMChannel.prototype.sendTTSMessage = function sendTTSMessage() {
+		return this.client.sendTTSMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	_createClass(PMChannel, [{
+		key: "lastMessage",
+		get: function get() {
+			return this.messages.get("id", this.lastMessageID);
+		}
+	}]);
+
+	return PMChannel;
+})(_Channel3["default"]);
+
+exports["default"] = PMChannel;
+module.exports = exports["default"];

lib/Structures/PermissionOverwrite.js

@@ -0,0 +1,89 @@
+"use strict";
+
+exports.__esModule = true;
+
+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"); } }
+
+var _Constants = require("../Constants");
+
+var PermissionOverwrite = (function () {
+	function PermissionOverwrite(data) {
+		_classCallCheck(this, PermissionOverwrite);
+
+		this.id = data.id;
+		this.type = data.type; // member or role
+		this.deny = data.deny;
+		this.allow = data.allow;
+	}
+
+	// returns an array of allowed permissions
+
+	PermissionOverwrite.prototype.setAllowed = function setAllowed(allowedArray) {
+		var _this = this;
+
+		allowedArray.forEach(function (permission) {
+			if (permission instanceof String || typeof permission === "string") {
+				permission = _Constants.Permissions[permission];
+			}
+			if (permission) {
+				_this.allow |= 1 << permission;
+			}
+		});
+	};
+
+	PermissionOverwrite.prototype.setDenied = function setDenied(deniedArray) {
+		var _this2 = this;
+
+		deniedArray.forEach(function (permission) {
+			if (permission instanceof String || typeof permission === "string") {
+				permission = _Constants.Permissions[permission];
+			}
+			if (permission) {
+				_this2.deny |= 1 << permission;
+			}
+		});
+	};
+
+	_createClass(PermissionOverwrite, [{
+		key: "allowed",
+		get: function get() {
+			var allowed = [];
+			for (var permName in _Constants.Permissions) {
+				if (permName === "manageRoles" || permName === "manageChannels") {
+					// these permissions do not exist in overwrites.
+					continue;
+				}
+
+				if (!!(this.allow & _Constants.Permissions[permName])) {
+					allowed.push(permName);
+				}
+			}
+			return allowed;
+		}
+
+		// returns an array of denied permissions
+	}, {
+		key: "denied",
+		get: function get() {
+			var denied = [];
+			for (var permName in _Constants.Permissions) {
+				if (permName === "manageRoles" || permName === "manageChannels") {
+					// these permissions do not exist in overwrites.
+					continue;
+				}
+
+				if (!!(this.deny & _Constants.Permissions[permName])) {
+					denied.push(permName);
+				}
+			}
+			return denied;
+		}
+	}]);
+
+	return PermissionOverwrite;
+})();
+
+exports["default"] = PermissionOverwrite;
+module.exports = exports["default"];

lib/Structures/Role.js

@@ -0,0 +1,142 @@
+"use strict";
+exports.__esModule = true;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var _Constants = require("../Constants");
+
+/*
+
+example data
+
+{ position: -1,
+    permissions: 36953089,
+    name: '@everyone',
+    managed: false,
+    id: '110007368451915776',
+    hoist: false,
+    color: 0 }
+*/
+
+var DefaultRole = [_Constants.Permissions.createInstantInvite, _Constants.Permissions.readMessages, _Constants.Permissions.readMessageHistory, _Constants.Permissions.sendMessages, _Constants.Permissions.sendTTSMessages, _Constants.Permissions.embedLinks, _Constants.Permissions.attachFiles, _Constants.Permissions.readMessageHistory, _Constants.Permissions.mentionEveryone, _Constants.Permissions.voiceConnect, _Constants.Permissions.voiceSpeak, _Constants.Permissions.voiceUseVAD].reduce(function (previous, current) {
+	return previous | current;
+}, 0);
+
+var Role = (function () {
+	function Role(data, server, client) {
+		_classCallCheck(this, Role);
+
+		this.position = data.position || -1;
+		this.permissions = data.permissions || (data.name === "@everyone" ? DefaultRole : 0);
+		this.name = data.name || "@everyone";
+		this.managed = data.managed || false;
+		this.id = data.id;
+		this.hoist = data.hoist || false;
+		this.color = data.color || 0;
+		this.server = server;
+		this.client = client;
+	}
+
+	Role.prototype.serialise = function serialise(explicit) {
+		var _this = this;
+
+		var hp = function hp(perm) {
+			return _this.hasPermission(perm, explicit);
+		};
+
+		return {
+			// general
+			createInstantInvite: hp(_Constants.Permissions.createInstantInvite),
+			kickMembers: hp(_Constants.Permissions.kickMembers),
+			banMembers: hp(_Constants.Permissions.banMembers),
+			manageRoles: hp(_Constants.Permissions.manageRoles),
+			manageChannels: hp(_Constants.Permissions.manageChannels),
+			manageServer: hp(_Constants.Permissions.manageServer),
+			// text
+			readMessages: hp(_Constants.Permissions.readMessages),
+			sendMessages: hp(_Constants.Permissions.sendMessages),
+			sendTTSMessages: hp(_Constants.Permissions.sendTTSMessages),
+			manageMessages: hp(_Constants.Permissions.manageMessages),
+			embedLinks: hp(_Constants.Permissions.embedLinks),
+			attachFiles: hp(_Constants.Permissions.attachFiles),
+			readMessageHistory: hp(_Constants.Permissions.readMessageHistory),
+			mentionEveryone: hp(_Constants.Permissions.mentionEveryone),
+			// voice
+			voiceConnect: hp(_Constants.Permissions.voiceConnect),
+			voiceSpeak: hp(_Constants.Permissions.voiceSpeak),
+			voiceMuteMembers: hp(_Constants.Permissions.voiceMuteMembers),
+			voiceDeafenMembers: hp(_Constants.Permissions.voiceDeafenMembers),
+			voiceMoveMembers: hp(_Constants.Permissions.voiceMoveMembers),
+			voiceUseVAD: hp(_Constants.Permissions.voiceUseVAD)
+		};
+	};
+
+	Role.prototype.serialize = function serialize() {
+		// ;n;
+		return this.serialise();
+	};
+
+	Role.prototype.hasPermission = function hasPermission(perm) {
+		var explicit = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
+
+		if (perm instanceof String || typeof perm === "string") {
+			perm = _Constants.Permissions[perm];
+		}
+		if (!perm) {
+			return false;
+		}
+		if (!explicit) {
+			// implicit permissions allowed
+			if (!!(this.permissions & _Constants.Permissions.manageRoles)) {
+				// manageRoles allowed, they have all permissions
+				return true;
+			}
+		}
+		// e.g.
+		// !!(36953089 & Permissions.manageRoles) = not allowed to manage roles
+		// !!(36953089 & (1 << 21)) = voice speak allowed
+
+		return !!(this.permissions & perm);
+	};
+
+	Role.prototype.setPermission = function setPermission(permission, value) {
+		if (permission instanceof String || typeof permission === "string") {
+			permission = _Constants.Permissions[permission];
+		}
+		if (permission) {
+			// valid permission
+			if (value) {
+				this.permissions |= permission;
+			} else {
+				this.permissions &= ~permission;
+			}
+		}
+	};
+
+	Role.prototype.setPermissions = function setPermissions(obj) {
+		var _this2 = this;
+
+		obj.forEach(function (value, permission) {
+			if (permission instanceof String || typeof permission === "string") {
+				permission = _Constants.Permissions[permission];
+			}
+			if (permission) {
+				// valid permission
+				_this2.setPermission(permission, value);
+			}
+		});
+	};
+
+	Role.prototype.colorAsHex = function colorAsHex() {
+		var val = this.color.toString();
+		while (val.length < 6) {
+			val = "0" + val;
+		}
+		return "#" + val;
+	};
+
+	return Role;
+})();
+
+exports["default"] = Role;
+module.exports = exports["default"];

lib/Structures/Server.js

@@ -0,0 +1,192 @@
+"use strict";
+
+exports.__esModule = true;
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _UtilEquality = require("../Util/Equality");
+
+var _UtilEquality2 = _interopRequireDefault(_UtilEquality);
+
+var _Constants = require("../Constants");
+
+var _UtilCache = require("../Util/Cache");
+
+var _UtilCache2 = _interopRequireDefault(_UtilCache);
+
+var _User = require("./User");
+
+var _User2 = _interopRequireDefault(_User);
+
+var _TextChannel = require("./TextChannel");
+
+var _TextChannel2 = _interopRequireDefault(_TextChannel);
+
+var _VoiceChannel = require("./VoiceChannel");
+
+var _VoiceChannel2 = _interopRequireDefault(_VoiceChannel);
+
+var _Role = require("./Role");
+
+var _Role2 = _interopRequireDefault(_Role);
+
+var strictKeys = ["region", "ownerID", "name", "id", "icon", "afkTimeout", "afkChannelID"];
+
+var Server = (function (_Equality) {
+	_inherits(Server, _Equality);
+
+	function Server(data, client) {
+		var _this = this;
+
+		_classCallCheck(this, Server);
+
+		_Equality.call(this);
+
+		var self = this;
+		this.client = client;
+
+		this.region = data.region;
+		this.ownerID = data.owner_id;
+		this.name = data.name;
+		this.id = data.id;
+		this.members = new _UtilCache2["default"]();
+		this.channels = new _UtilCache2["default"]();
+		this.roles = new _UtilCache2["default"]();
+		this.icon = data.icon;
+		this.afkTimeout = data.afkTimeout;
+		this.afkChannelID = data.afk_channel_id;
+		this.memberMap = {};
+
+		var self = this;
+
+		data.roles.forEach(function (dataRole) {
+			_this.roles.add(new _Role2["default"](dataRole, _this, client));
+		});
+
+		data.members.forEach(function (dataUser) {
+			_this.memberMap[dataUser.user.id] = {
+				roles: dataUser.roles.map(function (pid) {
+					return self.roles.get("id", pid);
+				}),
+				mute: dataUser.mute,
+				deaf: dataUser.deaf,
+				joinedAt: Date.parse(dataUser.joined_at)
+			};
+			var user = client.internal.users.add(new _User2["default"](dataUser.user, client));
+			_this.members.add(user);
+		});
+
+		data.channels.forEach(function (dataChannel) {
+			if (dataChannel.type === "text") {
+				var channel = client.internal.channels.add(new _TextChannel2["default"](dataChannel, client, _this));
+				_this.channels.add(channel);
+			} else {
+				var channel = client.internal.channels.add(new _VoiceChannel2["default"](dataChannel, client, _this));
+				_this.channels.add(channel);
+			}
+		});
+
+		if (data.presences) {
+			for (var _iterator = data.presences, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+				var _ref;
+
+				if (_isArray) {
+					if (_i >= _iterator.length) break;
+					_ref = _iterator[_i++];
+				} else {
+					_i = _iterator.next();
+					if (_i.done) break;
+					_ref = _i.value;
+				}
+
+				var presence = _ref;
+
+				var user = client.internal.users.get("id", presence.user.id);
+				if (user) {
+					user.status = presence.status;
+					user.gameID = presence.game_id;
+				}
+			}
+		}
+	}
+
+	Server.prototype.rolesOfUser = function rolesOfUser(user) {
+		user = this.client.internal.resolver.resolveUser(user);
+		if (user) {
+			return this.memberMap[user.id] ? this.memberMap[user.id].roles : [];
+		} else {
+			return null;
+		}
+	};
+
+	Server.prototype.rolesOf = function rolesOf(user) {
+		return this.rolesOfUser(user);
+	};
+
+	Server.prototype.toString = function toString() {
+		return this.name;
+	};
+
+	Server.prototype.equalsStrict = function equalsStrict(obj) {
+		if (obj instanceof Server) {
+			for (var _iterator2 = strictKeys, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+				var _ref2;
+
+				if (_isArray2) {
+					if (_i2 >= _iterator2.length) break;
+					_ref2 = _iterator2[_i2++];
+				} else {
+					_i2 = _iterator2.next();
+					if (_i2.done) break;
+					_ref2 = _i2.value;
+				}
+
+				var key = _ref2;
+
+				if (obj[key] !== this[key]) {
+					return false;
+				}
+			}
+		} else {
+			return false;
+		}
+		return true;
+	};
+
+	_createClass(Server, [{
+		key: "iconURL",
+		get: function get() {
+			if (!this.icon) {
+				return null;
+			} else {
+				return _Constants.Endpoints.SERVER_ICON(this.id, this.icon);
+			}
+		}
+	}, {
+		key: "afkChannel",
+		get: function get() {
+			return this.channels.get("id", this.afkChannelID);
+		}
+	}, {
+		key: "defaultChannel",
+		get: function get() {
+			return this.channels.get("id", this.id);
+		}
+	}, {
+		key: "owner",
+		get: function get() {
+			return this.members.get("id", this.ownerID);
+		}
+	}]);
+
+	return Server;
+})(_UtilEquality2["default"]);
+
+exports["default"] = Server;
+module.exports = exports["default"];

lib/Structures/ServerChannel.js

@@ -0,0 +1,134 @@
+"use strict";
+
+exports.__esModule = true;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _Channel2 = require("./Channel");
+
+var _Channel3 = _interopRequireDefault(_Channel2);
+
+var _UtilCache = require("../Util/Cache");
+
+var _UtilCache2 = _interopRequireDefault(_UtilCache);
+
+var _PermissionOverwrite = require("./PermissionOverwrite");
+
+var _PermissionOverwrite2 = _interopRequireDefault(_PermissionOverwrite);
+
+var _ChannelPermissions = require("./ChannelPermissions");
+
+var _ChannelPermissions2 = _interopRequireDefault(_ChannelPermissions);
+
+var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser");
+
+var ServerChannel = (function (_Channel) {
+	_inherits(ServerChannel, _Channel);
+
+	function ServerChannel(data, client, server) {
+		var _this = this;
+
+		_classCallCheck(this, ServerChannel);
+
+		_Channel.call(this, data, client);
+		this.name = data.name;
+		this.type = data.type;
+		this.position = data.position;
+		this.permissionOverwrites = new _UtilCache2["default"]();
+		this.server = server;
+		data.permission_overwrites.forEach(function (permission) {
+			_this.permissionOverwrites.add(new _PermissionOverwrite2["default"](permission));
+		});
+	}
+
+	ServerChannel.prototype.permissionsOf = function permissionsOf(user) {
+		user = this.client.internal.resolver.resolveUser(user);
+		if (user) {
+			if (this.server.owner.equals(user)) {
+				return new _ChannelPermissions2["default"](4294967295);
+			}
+			var everyoneRole = this.server.roles.get("name", "@everyone");
+
+			var userRoles = [everyoneRole].concat(this.server.rolesOf(user) || []);
+			var userRolesID = userRoles.map(function (v) {
+				return v.id;
+			});
+			var roleOverwrites = [],
+			    memberOverwrites = [];
+
+			this.permissionOverwrites.forEach(function (overwrite) {
+				if (overwrite.type === "member" && overwrite.id === user.id) {
+					memberOverwrites.push(overwrite);
+				} else if (overwrite.type === "role" && overwrite.id in userRolesID) {
+					roleOverwrites.push(overwrite);
+				}
+			});
+
+			var permissions = 0;
+
+			for (var _iterator = userRoles, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+				var _ref;
+
+				if (_isArray) {
+					if (_i >= _iterator.length) break;
+					_ref = _iterator[_i++];
+				} else {
+					_i = _iterator.next();
+					if (_i.done) break;
+					_ref = _i.value;
+				}
+
+				var serverRole = _ref;
+
+				permissions |= serverRole.permissions;
+			}
+
+			for (var _iterator2 = roleOverwrites.concat(memberOverwrites), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+				var _ref2;
+
+				if (_isArray2) {
+					if (_i2 >= _iterator2.length) break;
+					_ref2 = _iterator2[_i2++];
+				} else {
+					_i2 = _iterator2.next();
+					if (_i2.done) break;
+					_ref2 = _i2.value;
+				}
+
+				var overwrite = _ref2;
+
+				permissions = permissions & ~overwrite.deny;
+				permissions = permissions | overwrite.allow;
+			}
+
+			return new _ChannelPermissions2["default"](permissions);
+		} else {
+			return null;
+		}
+	};
+
+	ServerChannel.prototype.permsOf = function permsOf(user) {
+		return this.permissionsOf(user);
+	};
+
+	ServerChannel.prototype.mention = function mention() {
+		return "<#" + this.id + ">";
+	};
+
+	ServerChannel.prototype.toString = function toString() {
+		return this.mention();
+	};
+
+	ServerChannel.prototype.setName = function setName() {
+		return this.client.setChannelName.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	return ServerChannel;
+})(_Channel3["default"]);
+
+exports["default"] = ServerChannel;
+module.exports = exports["default"];

lib/Structures/TextChannel.js

@@ -0,0 +1,69 @@
+"use strict";
+
+exports.__esModule = true;
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _ServerChannel2 = require("./ServerChannel");
+
+var _ServerChannel3 = _interopRequireDefault(_ServerChannel2);
+
+var _UtilCache = require("../Util/Cache");
+
+var _UtilCache2 = _interopRequireDefault(_UtilCache);
+
+var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser");
+
+var TextChannel = (function (_ServerChannel) {
+	_inherits(TextChannel, _ServerChannel);
+
+	function TextChannel(data, client, server) {
+		_classCallCheck(this, TextChannel);
+
+		_ServerChannel.call(this, data, client, server);
+
+		this.topic = data.topic;
+		this.lastMessageID = data.last_message_id;
+		this.messages = new _UtilCache2["default"]("id", client.options.maximumMessages);
+	}
+
+	/* warning! may return null */
+
+	TextChannel.prototype.setTopic = function setTopic() {
+		return this.client.setTopic.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	TextChannel.prototype.setNameAndTopic = function setNameAndTopic() {
+		return this.client.setChannelNameAndTopic.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	TextChannel.prototype.update = function update() {
+		return this.client.updateChannel.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	TextChannel.prototype.sendMessage = function sendMessage() {
+		return this.client.sendMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	TextChannel.prototype.sendTTSMessage = function sendTTSMessage() {
+		return this.client.sendTTSMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments));
+	};
+
+	_createClass(TextChannel, [{
+		key: "lastMessage",
+		get: function get() {
+			return this.messages.get("id", this.lastMessageID);
+		}
+	}]);
+
+	return TextChannel;
+})(_ServerChannel3["default"]);
+
+exports["default"] = TextChannel;
+module.exports = exports["default"];

lib/Structures/User.js

@@ -0,0 +1,70 @@
+"use strict";
+
+exports.__esModule = true;
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _UtilEquality = require("../Util/Equality");
+
+var _UtilEquality2 = _interopRequireDefault(_UtilEquality);
+
+var _Constants = require("../Constants");
+
+var User = (function (_Equality) {
+	_inherits(User, _Equality);
+
+	function User(data, client) {
+		_classCallCheck(this, User);
+
+		_Equality.call(this);
+		this.client = client;
+		this.username = data.username;
+		this.discriminator = data.discriminator;
+		this.id = data.id;
+		this.avatar = data.avatar;
+		this.status = data.status || "offline";
+		this.gameID = data.game_id || null;
+		this.typing = {
+			since: null,
+			channel: null
+		};
+	}
+
+	User.prototype.mention = function mention() {
+		return "<@" + this.id + ">";
+	};
+
+	User.prototype.toString = function toString() {
+		return this.mention();
+	};
+
+	User.prototype.equalsStrict = function equalsStrict(obj) {
+		if (obj instanceof User) return this.id === obj.id && this.username === obj.username && this.discriminator === obj.discriminator && this.avatar === obj.avatar && this.status === obj.status && this.gameID === obj.gameID;else return false;
+	};
+
+	User.prototype.equals = function equals(obj) {
+		if (obj instanceof User) return this.id === obj.id && this.username === obj.username && this.discriminator === obj.discriminator && this.avatar === obj.avatar;else return false;
+	};
+
+	_createClass(User, [{
+		key: "avatarURL",
+		get: function get() {
+			if (!this.avatar) {
+				return null;
+			} else {
+				return _Constants.Endpoints.AVATAR(this.id, this.avatar);
+			}
+		}
+	}]);
+
+	return User;
+})(_UtilEquality2["default"]);
+
+exports["default"] = User;
+module.exports = exports["default"];

lib/Structures/VoiceChannel.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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 _ServerChannel2 = require("./ServerChannel");
+
+var _ServerChannel3 = _interopRequireDefault(_ServerChannel2);
+
+var VoiceChannel = (function (_ServerChannel) {
+	_inherits(VoiceChannel, _ServerChannel);
+
+	function VoiceChannel(data, client, server) {
+		_classCallCheck(this, VoiceChannel);
+
+		_ServerChannel.call(this, data, client, server);
+	}
+
+	return VoiceChannel;
+})(_ServerChannel3["default"]);
+
+exports["default"] = VoiceChannel;
+module.exports = exports["default"];