Remove selfbot support

While selfbots have always been "roughly tolerated", lately they have
been tolerated to less of a degree.

The simple answer is to no longer support selfbots in any form. This is
done for a few of reasons: 1) in anticipation of selfbots no longer
being tolerated; 2) there are few reasons why one should make a selfbot
in Rust and not a scripting language; 3) there are alternatives
(i.e. discord-rs) that still support userbots. Selfbots are simply not
a goal of the maintainer of serenity.

Upgrade path:

Don't use selfbots with serenity. Use discord-rs instead.

The following has been removed:

Enums:

- `RelationshipType`

Structs:

- `FriendSourceFlags`
- `ReadState`
- `Relationship`
- `SearchResult`
- `SuggestionReason`
- `Tutorial`
- `UserConnection`
- `UserGuildSettings`
- `UserSettings`

Removed the following fields:

- `CurrentUser::mobile`
- Ready::{
     analytics_token,
     experiments,
     friend_suggestion_count,
     notes,
     read_state,
     relationships,
     tutorial,
     user_guild_settings,
     user_settings,
 }

Removed the following methods:

- `Client::login_user`

Deprecated `Client::login_bot` in favour of `Client::login`.

Removed `client::LoginType`.

The following no longer take a `login_type` parameter:

- `Context::new`
- `Shard::new`

`Shard::sync_guilds` has been removed.

The `client::Error::{InvalidOperationAsBot, InvalidOperationAsUser}`
variants have been removed.

The following event handlers on `Client` have been removed:

- `on_friend_suggestion_create`
- `on_friend_suggestion_delete`
- `on_relationship_add`
- `on_relationship_remove`
- `on_user_guild_settings_update`
- `on_note_update`
- `on_user_settings_update`

The following `client::rest` functions have been removed:

- `ack_message`
- `edit_note`
- `get_user_connections`
- `search_channel_messages`
- `search_guild_messages`

The following `client::rest::ratelimiting::Route` variants have been
removed:

- `ChannelsIdMessagesSearch`
- `GuildsIdMessagesSearch`
- `UsersMeConnections`

The following fields on `ext::cache::Cache` have been removed:

- `guild_settings`
- `relationships`
- `settings`

while the following methods have also been removed:

- `update_with_relationship_add`
- `update_with_relationship_remove`
- `update_with_user_guild_settings_update`
- `update_with_user_note_update`
- `update_with_user_settings_update`

The following methods have been removed across models:

- `ChannelId::{ack, search}`
- `Channel::{ack, search}`
- `Group::{ack, search}`
- `GuildChannel::{ack, search}`
- `GuildId::{search, search_channels}`
- `Guild::{search, search_channels}`
- `Message::ack`
- `PartialGuild::{search, search_channels}`
- `PrivateChannel::{ack, search}`
- `UserId::{delete_note, edit_note}`
- `User::{delete_note, edit_note}`

The following events in `model::events` have been removed:

- `FriendSuggestionCreateEvent`
- `FriendSuggestionDeleteEvent`
- `MessageAckEvent`
- `RelationshipAddEvent`
- `RelationshipRemoveEvent`
- `UserGuildSettingsUpdateEvent`
- `UserNoteUpdateEvent`
- `UserSettingsUpdateEvent`

Consequently, the following variants on `model::event::Event` have been
removed:

- `FriendSuggestionCreate`
- `FriendSuggestionDelete`
- `MessageAdd`
- `RelationshipAdd`
- `RelationshipRemove`
- `UserGuildSettingUpdate`
- `UserNoteUpdate`
- `UserSettingsUpdate`

The `utils::builder::Search` search builder has been removed.

9 files changed, 83 insertions, 544 deletions

diff --git a/src/client/context.rs b/src/client/context.rs
index f46e351..d208140 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -2,7 +2,6 @@ use serde_json::builder::ObjectBuilder;
 use std::sync::{Arc, Mutex};
 use super::gateway::Shard;
 use super::rest;
-use super::login_type::LoginType;
 use typemap::ShareMap;
 use ::utils::builder::EditProfile;
 use ::internal::prelude::*;
@@ -45,7 +44,6 @@ pub struct Context {
     pub shard: Arc<Mutex<Shard>>,
     /// The queue of messages that are sent after context goes out of scope.
     pub queue: String,
-    login_type: LoginType,
 }
 
 impl Context {
@@ -59,13 +57,11 @@ impl Context {
     #[doc(hidden)]
     pub fn new(channel_id: Option<ChannelId>,
                shard: Arc<Mutex<Shard>>,
-               data: Arc<Mutex<ShareMap>>,
-               login_type: LoginType) -> Context {
+               data: Arc<Mutex<ShareMap>>) -> Context {
         Context {
             channel_id: channel_id,
             data: data,
             shard: shard,
-            login_type: login_type,
             queue: String::new(),
         }
     }
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 33267ff..49dbdb0 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -1,7 +1,6 @@
 use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
 use super::event_store::EventStore;
-use super::login_type::LoginType;
 use super::Context;
 use super::gateway::Shard;
 use typemap::ShareMap;
@@ -61,9 +60,8 @@ macro_rules! update {
 
 fn context(channel_id: Option<ChannelId>,
            conn: &Arc<Mutex<Shard>>,
-           data: &Arc<Mutex<ShareMap>>,
-           login_type: LoginType) -> Context {
-    Context::new(channel_id, conn.clone(), data.clone(), login_type)
+           data: &Arc<Mutex<ShareMap>>) -> Context {
+    Context::new(channel_id, conn.clone(), data.clone())
 }
 
 #[cfg(feature="framework")]
@@ -71,14 +69,12 @@ pub fn dispatch(event: Event,
                 conn: &Arc<Mutex<Shard>>,
                 framework: &Arc<Mutex<Framework>>,
                 data: &Arc<Mutex<ShareMap>>,
-                login_type: LoginType,
                 event_store: &Arc<RwLock<EventStore>>) {
     match event {
         Event::MessageCreate(event) => {
             let context = context(Some(event.message.channel_id),
                                   conn,
-                                  data,
-                                  login_type);
+                                  data);
             let mut framework = framework.lock().unwrap();
 
             if framework.initialized {
@@ -91,7 +87,7 @@ pub fn dispatch(event: Event,
                 dispatch_message(context, event.message, event_store);
             }
         },
-        other => handle_event(other, conn, data, login_type, event_store),
+        other => handle_event(other, conn, data, event_store),
     }
 }
 
@@ -99,19 +95,15 @@ pub fn dispatch(event: Event,
 pub fn dispatch(event: Event,
                 conn: &Arc<Mutex<Shard>>,
                 data: &Arc<Mutex<ShareMap>>,
-                login_type: LoginType,
                 event_store: &Arc<RwLock<EventStore>>) {
     match event {
         Event::MessageCreate(event) => {
-            let context = context(Some(event.message.channel_id),
-                                  conn,
-                                  data,
-                                  login_type);
+            let context = context(Some(event.message.channel_id), conn, data);
             dispatch_message(context,
                              event.message,
                              event_store);
         },
-        other => handle_event(other, conn, data, login_type, event_store),
+        other => handle_event(other, conn, data, event_store),
     }
 }
 
@@ -127,14 +119,13 @@ fn dispatch_message(context: Context,
 fn handle_event(event: Event,
                 conn: &Arc<Mutex<Shard>>,
                 data: &Arc<Mutex<ShareMap>>,
-                login_type: LoginType,
                 event_store: &Arc<RwLock<EventStore>>) {
     match event {
         Event::CallCreate(event) => {
             if let Some(handler) = handler!(on_call_create, event_store) {
                 update!(update_with_call_create, event);
 
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.call));
             } else {
@@ -143,7 +134,7 @@ fn handle_event(event: Event,
         },
         Event::CallDelete(event) => {
             if let Some(handler) = handler!(on_call_delete, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let call = update!(update_with_call_delete, event);
@@ -158,7 +149,7 @@ fn handle_event(event: Event,
         },
         Event::CallUpdate(event) => {
             if let Some(handler) = handler!(on_call_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_call_update, event, true);
@@ -183,10 +174,7 @@ fn handle_event(event: Event,
         Event::ChannelCreate(event) => {
             if let Some(handler) = handler!(on_channel_create, event_store) {
                 update!(update_with_channel_create, event);
-                let context = context(Some(event.channel.id()),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel.id()), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel));
             } else {
@@ -196,7 +184,7 @@ fn handle_event(event: Event,
         Event::ChannelDelete(event) => {
             if let Some(handler) = handler!(on_channel_delete, event_store) {
                 update!(update_with_channel_delete, event);
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel));
             } else {
@@ -205,20 +193,14 @@ fn handle_event(event: Event,
         },
         Event::ChannelPinsAck(event) => {
             if let Some(handler) = handler!(on_channel_pins_ack, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::ChannelPinsUpdate(event) => {
             if let Some(handler) = handler!(on_channel_pins_update, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -227,10 +209,7 @@ fn handle_event(event: Event,
             update!(update_with_channel_recipient_add, @event);
 
             if let Some(handler) = handler!(on_channel_recipient_addition, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.user));
             }
@@ -239,20 +218,14 @@ fn handle_event(event: Event,
             update!(update_with_channel_recipient_remove, event);
 
             if let Some(handler) = handler!(on_channel_recipient_removal, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.user));
             }
         },
         Event::ChannelUpdate(event) => {
             if let Some(handler) = handler!(on_channel_update, event_store) {
-                let context = context(Some(event.channel.id()),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel.id()), conn, data);
 
                 feature_cache! {{
                     let before = CACHE.read()
@@ -268,30 +241,16 @@ fn handle_event(event: Event,
                 update!(update_with_channel_update, event);
             }
         },
-        Event::FriendSuggestionCreate(event) => {
-            if let Some(handler) = handler!(on_friend_suggestion_create, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.suggested_user, event.reasons));
-            }
-        },
-        Event::FriendSuggestionDelete(event) => {
-            if let Some(handler) = handler!(on_friend_suggestion_delete, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.suggested_user_id));
-            }
-        },
         Event::GuildBanAdd(event) => {
             if let Some(handler) = handler!(on_guild_ban_addition, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.user));
             }
         },
         Event::GuildBanRemove(event) => {
             if let Some(handler) = handler!(on_guild_ban_removal, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.user));
             }
@@ -300,14 +259,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_create, event);
 
             if let Some(handler) = handler!(on_guild_create, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild));
             }
         },
         Event::GuildDelete(event) => {
             if let Some(handler) = handler!(on_guild_delete, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let full = update!(update_with_guild_delete, event);
@@ -327,14 +286,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_emojis_update, event);
 
             if let Some(handler) = handler!(on_guild_emojis_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.emojis));
             }
         },
         Event::GuildIntegrationsUpdate(event) => {
             if let Some(handler) = handler!(on_guild_integrations_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id));
             }
@@ -343,14 +302,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_member_add, @event);
 
             if let Some(handler) = handler!(on_guild_member_addition, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.member));
             }
         },
         Event::GuildMemberRemove(event) => {
             if let Some(handler) = handler!(on_guild_member_removal, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let member = update!(update_with_guild_member_remove, event);
@@ -368,7 +327,7 @@ fn handle_event(event: Event,
         },
         Event::GuildMemberUpdate(event) => {
             if let Some(handler) = handler!(on_guild_member_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_guild_member_update, event);
@@ -394,7 +353,7 @@ fn handle_event(event: Event,
             update!(update_with_guild_members_chunk, event);
 
             if let Some(handler) = handler!(on_guild_members_chunk, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.members));
             }
@@ -403,14 +362,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_role_create, event);
 
             if let Some(handler) = handler!(on_guild_role_create, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.role));
             }
         },
         Event::GuildRoleDelete(event) => {
             if let Some(handler) = handler!(on_guild_role_delete, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let role = update!(update_with_guild_role_delete, event);
@@ -428,7 +387,7 @@ fn handle_event(event: Event,
         },
         Event::GuildRoleUpdate(event) => {
             if let Some(handler) = handler!(on_guild_role_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_guild_role_update, event);
@@ -446,7 +405,7 @@ fn handle_event(event: Event,
         },
         Event::GuildSync(event) => {
             if let Some(handler) = handler!(on_guild_sync, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -455,14 +414,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_unavailable, event);
 
             if let Some(handler) = handler!(on_guild_unavailable, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id));
             }
         },
         Event::GuildUpdate(event) => {
             if let Some(handler) = handler!(on_guild_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = CACHE.read()
@@ -479,45 +438,26 @@ fn handle_event(event: Event,
             } else {
                 update!(update_with_guild_update, event);
             }
-        }
-        Event::MessageAck(event) => {
-            if let Some(handler) = handler!(on_message_ack, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
-
-                thread::spawn(move || (handler)(context, event.channel_id, event.message_id));
-            }
         },
         // Already handled by the framework check macro
         Event::MessageCreate(_) => {},
         Event::MessageDeleteBulk(event) => {
             if let Some(handler) = handler!(on_message_delete_bulk, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.ids));
             }
         },
         Event::MessageDelete(event) => {
             if let Some(handler) = handler!(on_message_delete, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.message_id));
             }
         },
         Event::MessageUpdate(event) => {
             if let Some(handler) = handler!(on_message_update, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -526,7 +466,7 @@ fn handle_event(event: Event,
             update!(update_with_presences_replace, event);
 
             if let Some(handler) = handler!(on_presence_replace, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.presences));
             }
@@ -535,37 +475,28 @@ fn handle_event(event: Event,
             update!(update_with_presence_update, @event);
 
             if let Some(handler) = handler!(on_presence_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::ReactionAdd(event) => {
             if let Some(handler) = handler!(on_reaction_add, event_store) {
-                let context = context(Some(event.reaction.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.reaction.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.reaction));
             }
         },
         Event::ReactionRemove(event) => {
             if let Some(handler) = handler!(on_reaction_remove, event_store) {
-                let context = context(Some(event.reaction.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.reaction.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.reaction));
             }
         },
         Event::ReactionRemoveAll(event) => {
             if let Some(handler) = handler!(on_reaction_remove_all, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.message_id));
             }
@@ -574,117 +505,37 @@ fn handle_event(event: Event,
             if let Some(handler) = handler!(on_ready, event_store) {
                 update!(update_with_ready, event);
 
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.ready));
             } else {
                 update!(update_with_ready, event);
             }
         },
-        Event::RelationshipAdd(event) => {
-            update!(update_with_relationship_add, event);
-
-            if let Some(handler) = handler!(on_relationship_addition, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.relationship));
-            }
-        },
-        Event::RelationshipRemove(event) => {
-            update!(update_with_relationship_remove, event);
-
-            if let Some(handler) = handler!(on_relationship_removal, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.user_id, event.kind));
-            }
-        },
         Event::Resumed(event) => {
             if let Some(handler) = handler!(on_resume, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::TypingStart(event) => {
             if let Some(handler) = handler!(on_typing_start, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::Unknown(event) => {
             if let Some(handler) = handler!(on_unknown, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.kind, event.value));
             }
         },
-        Event::UserGuildSettingsUpdate(event) => {
-            if let Some(handler) = handler!(on_user_guild_settings_update, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                feature_cache! {{
-                    let before = update!(update_with_user_guild_settings_update, event);
-
-                    thread::spawn(move || (handler)(context, before, event.settings));
-                } else {
-                    thread::spawn(move || (handler)(context, event.settings));
-                }}
-            } else {
-                #[cfg(feature="cache")]
-                {
-                    let _ = update!(update_with_user_guild_settings_update, event);
-                }
-            }
-        },
-        Event::UserNoteUpdate(event) => {
-            if let Some(handler) = handler!(on_note_update, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                feature_cache! {{
-                    let before = update!(update_with_user_note_update, event);
-
-                    thread::spawn(move || (handler)(context, event.user_id, before, event.note));
-                } else {
-                    thread::spawn(move || (handler)(context, event.user_id, event.note));
-                }}
-            } else {
-                #[cfg(feature="cache")]
-                {
-                    let _ = update!(update_with_user_note_update, event);
-                }
-            }
-        },
-        Event::UserSettingsUpdate(event) => {
-            if let Some(handler) = handler!(on_user_settings_update, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                feature_cache! {{
-                    let before = update!(update_with_user_settings_update, event, true);
-                    let after = CACHE.read().unwrap().settings.clone();
-
-                    // Unwrap in the spawned thread so that if they don't
-                    // actually exist, then the current thread won't panic.
-                    //
-                    // Yes, this is probably bad.
-                    thread::spawn(move || (handler)(context, before.unwrap(), after.unwrap()));
-                } else {
-                    thread::spawn(move || (handler)(context, event));
-                }}
-            } else {
-                #[cfg(feature="cache")]
-                {
-                    update!(update_with_user_settings_update, event, false);
-                }
-            }
-        },
         Event::UserUpdate(event) => {
             if let Some(handler) = handler!(on_user_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_user_update, event);
@@ -702,7 +553,7 @@ fn handle_event(event: Event,
         },
         Event::VoiceServerUpdate(event) => {
             if let Some(handler) = handler!(on_voice_server_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -711,14 +562,14 @@ fn handle_event(event: Event,
             update!(update_with_voice_state_update, event);
 
             if let Some(handler) = handler!(on_voice_state_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.voice_state));
             }
         },
         Event::WebhookUpdate(event) => {
             if let Some(handler) = handler!(on_webhook_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.channel_id));
             }
diff --git a/src/client/error.rs b/src/client/error.rs
index 30d3c27..6a18b7a 100644
--- a/src/client/error.rs
+++ b/src/client/error.rs
@@ -19,7 +19,7 @@ use ::model::{ChannelType, Permissions};
 /// use std::env;
 ///
 /// let token = env::var("DISCORD_BOT_TOKEN").unwrap();
-/// let mut client = Client::login_bot(&token);
+/// let mut client = Client::login(&token);
 ///
 /// client.on_member_unban(|context, guild_id, user| {
 ///     let discriminator = user.discriminator.parse::<u16>().unwrap();
@@ -74,12 +74,6 @@ pub enum Error {
     GuildNotFound,
     /// An indicator that an unknown opcode was received from the gateway.
     InvalidOpCode,
-    /// When attempting to perform an action which is only available to user
-    /// accounts.
-    InvalidOperationAsBot,
-    /// When attempting to perform an action which is only available to bot
-    /// accounts.
-    InvalidOperationAsUser,
     /// Indicates that you do not have the required permissions to perform an
     /// operation.
     ///
diff --git a/src/client/event_store.rs b/src/client/event_store.rs
index f63c03a..cc74d63 100644
--- a/src/client/event_store.rs
+++ b/src/client/event_store.rs
@@ -18,11 +18,7 @@ use ::model::*;
 use std::sync::RwLock;
 
 #[cfg(not(feature="cache"))]
-use ::model::event::{
-    CallUpdateEvent,
-    GuildMemberUpdateEvent,
-    UserSettingsUpdateEvent,
-};
+use ::model::event::{CallUpdateEvent, GuildMemberUpdateEvent};
 
 // This should use type macros when stable receives the type macro
 // stabilization patch.
@@ -64,8 +60,6 @@ pub struct EventStore {
     pub on_channel_update: Option<Arc<Fn(Context, Option<Channel>, Channel) + Send + Sync + 'static>>,
     #[cfg(not(feature="cache"))]
     pub on_channel_update: Option<Arc<Fn(Context, Channel) + Send + Sync + 'static>>,
-    pub on_friend_suggestion_create: Option<Arc<Fn(Context, User, Vec<SuggestionReason>) + Send + Sync + 'static>>,
-    pub on_friend_suggestion_delete: Option<Arc<Fn(Context, UserId) + Send + Sync + 'static>>,
     pub on_guild_ban_addition: Option<Arc<Fn(Context, GuildId, User) + Send + Sync + 'static>>,
     pub on_guild_ban_removal: Option<Arc<Fn(Context, GuildId, User) + Send + Sync + 'static>>,
     pub on_guild_create: Option<Arc<Fn(Context, Guild) + Send + Sync + 'static>>,
@@ -108,30 +102,16 @@ pub struct EventStore {
     pub on_reaction_remove: Option<Arc<Fn(Context, Reaction) + Send + Sync + 'static>>,
     pub on_reaction_remove_all: Option<Arc<Fn(Context, ChannelId, MessageId) + Send + Sync + 'static>>,
     pub on_message_update: Option<Arc<Fn(Context, MessageUpdateEvent) + Send + Sync + 'static>>,
-    #[cfg(feature="cache")]
-    pub on_note_update: Option<Arc<Fn(Context, UserId, Option<String>, String) + Send + Sync + 'static>>,
-    #[cfg(not(feature="cache"))]
-    pub on_note_update: Option<Arc<Fn(Context, UserId, String) + Send + Sync + 'static>>,
     pub on_presence_replace: Option<Arc<Fn(Context, Vec<Presence>) + Send + Sync + 'static>>,
     pub on_presence_update: Option<Arc<Fn(Context, PresenceUpdateEvent) + Send + Sync + 'static>>,
     pub on_ready: Option<Arc<Fn(Context, Ready) + Send + Sync + 'static>>,
-    pub on_relationship_addition: Option<Arc<Fn(Context, Relationship) + Send + Sync + 'static>>,
-    pub on_relationship_removal: Option<Arc<Fn(Context, UserId, RelationshipType) + Send + Sync + 'static>>,
     pub on_resume: Option<Arc<Fn(Context, ResumedEvent) + Send + Sync + 'static>>,
     pub on_typing_start: Option<Arc<Fn(Context, TypingStartEvent) + Send + Sync + 'static>>,
     pub on_unknown: Option<Arc<Fn(Context, String, BTreeMap<String, Value>) + Send + Sync + 'static>>,
     #[cfg(feature="cache")]
-    pub on_user_guild_settings_update: Option<Arc<Fn(Context, Option<UserGuildSettings>, UserGuildSettings) + Send + Sync + 'static>>,
-    #[cfg(not(feature="cache"))]
-    pub on_user_guild_settings_update: Option<Arc<Fn(Context, UserGuildSettings) + Send + Sync + 'static>>,
-    #[cfg(feature="cache")]
     pub on_user_update: Option<Arc<Fn(Context, CurrentUser, CurrentUser) + Send + Sync + 'static>>,
     #[cfg(not(feature="cache"))]
     pub on_user_update: Option<Arc<Fn(Context, CurrentUser) + Send + Sync + 'static>>,
-    #[cfg(feature="cache")]
-    pub on_user_settings_update: Option<Arc<Fn(Context, UserSettings, UserSettings) + Send + Sync + 'static>>,
-    #[cfg(not(feature="cache"))]
-    pub on_user_settings_update: Option<Arc<Fn(Context, UserSettingsUpdateEvent) + Send + Sync + 'static>>,
     pub on_voice_server_update: Option<Arc<Fn(Context, VoiceServerUpdateEvent) + Send + Sync + 'static>>,
     pub on_voice_state_update: Option<Arc<Fn(Context, Option<GuildId>, VoiceState) + Send + Sync + 'static>>,
     pub on_webhook_update: Option<Arc<Fn(Context, GuildId, ChannelId) + Send + Sync + 'static>>,
diff --git a/src/client/gateway/shard.rs b/src/client/gateway/shard.rs
index e4c4720..f42c52a 100644
--- a/src/client/gateway/shard.rs
+++ b/src/client/gateway/shard.rs
@@ -6,7 +6,6 @@ use std::sync::{Arc, Mutex};
 use std::thread::{self, Builder as ThreadBuilder};
 use std::time::{Duration as StdDuration, Instant};
 use std::mem;
-use super::super::login_type::LoginType;
 use super::super::rest;
 use super::{GatewayError, GatewayStatus, prep};
 use time;
@@ -73,7 +72,6 @@ pub struct Shard {
     heartbeat_instants: (Arc<Mutex<Instant>>, Option<Instant>),
     keepalive_channel: MpscSender<GatewayStatus>,
     seq: u64,
-    login_type: LoginType,
     session_id: Option<String>,
     shard_info: Option<[u64; 2]>,
     token: String,
@@ -96,13 +94,13 @@ impl Shard {
     ///
     /// ```rust,ignore
     /// use serenity::client::gateway::Shard;
-    /// use serenity::client::{LoginType, rest};
+    /// use serenity::client::rest;
     /// use std::env;
     ///
     /// let token = env::var("DISCORD_BOT_TOKEN").expect("Token in environment");
     /// // retrieve the gateway response, which contains the URL to connect to
     /// let gateway = rest::get_gateway().expect("Valid gateway response").url;
-    /// let shard = Shard::new(&gateway, &token, None, LoginType::Bot)
+    /// let shard = Shard::new(&gateway, &token, None)
     ///     .expect("Working shard");
     ///
     /// // at this point, you can create a `loop`, and receive events and match
@@ -110,8 +108,7 @@ impl Shard {
     /// ```
     pub fn new(base_url: &str,
                token: &str,
-               shard_info: Option<[u64; 2]>,
-               login_type: LoginType)
+               shard_info: Option<[u64; 2]>)
                -> Result<(Shard, ReadyEvent, Receiver<WebSocketStream>)> {
         let url = prep::build_gateway_url(base_url)?;
 
@@ -162,7 +159,6 @@ impl Shard {
                 heartbeat_instants: (heartbeat_sent, None),
                 keepalive_channel: tx.clone(),
                 seq: sequence,
-                login_type: login_type,
                 token: token.to_owned(),
                 session_id: Some(ready.ready.session_id.clone()),
                 shard_info: shard_info,
@@ -175,7 +171,6 @@ impl Shard {
                 heartbeat_instants: (heartbeat_sent, None),
                 keepalive_channel: tx.clone(),
                 seq: sequence,
-                login_type: login_type,
                 token: token.to_owned(),
                 session_id: Some(ready.ready.session_id.clone()),
                 shard_info: shard_info,
@@ -528,16 +523,6 @@ impl Shard {
         let _ = self.keepalive_channel.send(GatewayStatus::SendMessage(msg));
     }
 
-    /// Syncs the user's guilds.
-    pub fn sync_guilds(&self, guild_ids: &[GuildId]) {
-        let msg = ObjectBuilder::new()
-            .insert("op", OpCode::SyncGuild.num())
-            .insert_array("d", |a| guild_ids.iter().fold(a, |a, s| a.push(s.0)))
-            .build();
-
-        let _ = self.keepalive_channel.send(GatewayStatus::SendMessage(msg));
-    }
-
     #[allow(unused_variables)]
     fn handle_dispatch(&mut self, event: &Event) {
         #[cfg(feature="voice")]
@@ -570,8 +555,7 @@ impl Shard {
 
             let shard = Shard::new(&gateway_url,
                                    &self.token,
-                                   self.shard_info,
-                                   self.login_type);
+                                   self.shard_info);
 
             if let Ok((shard, ready, receiver_new)) = shard {
                 let _ = Shard::shutdown(&mut receiver);
diff --git a/src/client/login_type.rs b/src/client/login_type.rs
deleted file mode 100644
index 4eae5e2..0000000
--- a/src/client/login_type.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-/// The type of login to perform.
-///
-/// Use [`Bot`] if you are using a bot which responds to others, created through
-/// the [applications page]. See the [`README`] for more information on using
-/// bots.
-///
-/// Use [`User`] if you are creating a selfbot which responds only to you.
-///
-/// [`Bot`]: #variant.Bot
-/// [`README`]: https://github.com/zeyla/serenity/blob/master/README.md#Bots
-/// [`User`]: #variant.User
-/// [applications page]: https://discordapp.com/developers/applications/me
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug, Ord, PartialOrd)]
-pub enum LoginType {
-    /// An indicator to login as a bot. This will automatically prefix your
-    /// token with `"Bot "`, which is a requirement by Discord.
-    Bot,
-    /// An indicator to login under your own user account token. Only use this
-    /// if you are creating a "selfbot", which triggers on events from yourself.
-    ///
-    /// **Note**: _Do not_ use this for a "userbot" which responds to others, or
-    /// you _can_ be banned.
-    User,
-}
diff --git a/src/client/mod.rs b/src/client/mod.rs
index e9ba20b..9286379 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -27,11 +27,9 @@ mod context;
 mod dispatch;
 mod error;
 mod event_store;
-mod login_type;
 
 pub use self::context::Context;
 pub use self::error::Error as ClientError;
-pub use self::login_type::LoginType;
 
 use self::dispatch::dispatch;
 use self::event_store::EventStore;
@@ -68,11 +66,7 @@ use ::ext::framework::Framework;
 use ::ext::cache::Cache;
 
 #[cfg(not(feature="cache"))]
-use ::model::event::{
-    CallUpdateEvent,
-    GuildMemberUpdateEvent,
-    UserSettingsUpdateEvent,
-};
+use ::model::event::{CallUpdateEvent, GuildMemberUpdateEvent};
 
 #[cfg(feature="cache")]
 lazy_static! {
@@ -135,7 +129,7 @@ lazy_static! {
 /// ```rust,ignore
 /// use serenity::Client;
 ///
-/// let mut client = Client::login_bot("my token here");
+/// let mut client = Client::login("my token here");
 ///
 /// client.on_message(|context, message| {
 ///     if message.content == "!ping" {
@@ -163,10 +157,10 @@ pub struct Client {
     /// In the meaning of a context, this data can be accessed through
     /// [`Context::data`].
     ///
-    /// Refer to [example 06] for an example on using the `data` field.
+    /// Refer to [example 05] for an example on using the `data` field.
     ///
     /// [`Context::data`]: struct.Context.html#method.data
-    /// [example 06]: https://github.com/zeyla/serenity/tree/master/examples/06_command_framework
+    /// [example 05]: https://github.com/zeyla/serenity/tree/master/examples/05_command_framework
     pub data: Arc<Mutex<ShareMap>>,
     /// A vector of all active shards that have received their [`Event::Ready`]
     /// payload, and have dispatched to [`on_ready`] if an event handler was
@@ -177,34 +171,32 @@ pub struct Client {
     event_store: Arc<RwLock<EventStore>>,
     #[cfg(feature="framework")]
     framework: Arc<Mutex<Framework>>,
-    login_type: LoginType,
     token: String,
 }
 
 #[allow(type_complexity)]
 impl Client {
+    /// Alias of [`login`].
+    ///
+    /// [`login`]: #method.login
+    #[deprecated(since="0.1.5", note="Use `login` instead")]
+    #[inline]
+    pub fn login_bot(token: &str) -> Self {
+        Self::login(token)
+    }
+
     /// Creates a Client for a bot user.
     ///
     /// Discord has a requirement of prefixing bot tokens with `"Bot "`, which
     /// this function will automatically do for you if not already included.
-    pub fn login_bot(bot_token: &str) -> Client {
+    pub fn login(bot_token: &str) -> Self {
         let token = if bot_token.starts_with("Bot ") {
             bot_token.to_owned()
         } else {
             format!("Bot {}", bot_token)
         };
 
-        login(token, LoginType::Bot)
-    }
-
-    /// Creates a Client for a user.
-    ///
-    /// **Note**: Read the notes for [`LoginType::User`] prior to using this, as
-    /// there are restrictions on usage.
-    ///
-    /// [`LoginType::User`]: enum.LoginType.html#variant.User
-    pub fn login_user(user_token: &str) -> Client {
-        login(user_token.to_owned(), LoginType::User)
+        login(token)
     }
 
     /// Sets a framework to be used with the client. All message events will be
@@ -322,7 +314,7 @@ impl Client {
     /// use std::env;
     ///
     /// let token = env::var("DISCORD_BOT_TOKEN").unwrap();
-    /// let mut client = Client::login_bot(&token);
+    /// let mut client = Client::login(&token);
     ///
     /// let _ = client.start_shard_range([4, 7], 10);
     /// ```
@@ -384,26 +376,6 @@ impl Client {
             .on_channel_pins_update = Some(Arc::new(handler));
     }
 
-    /// Attaches a handler for when a [`FriendSuggestionCreate`] is received.
-    ///
-    /// [`FriendSuggestionCreate`]: ../model/event/enum.Event.html#variant.FriendSuggestionCreate
-    pub fn on_friend_suggestion_create<F>(&mut self, handler: F)
-        where F: Fn(Context, User, Vec<SuggestionReason>) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_friend_suggestion_create = Some(Arc::new(handler));
-    }
-
-    /// Attaches a handler for when a [`FriendSuggestionDelete`] is received.
-    ///
-    /// [`FriendSuggestionDelete`]: ../model/event/enum.Event.html#variant.FriendSuggestionDelete
-    pub fn on_friend_suggestion_delete<F>(&mut self, handler: F)
-        where F: Fn(Context, UserId) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_friend_suggestion_delete = Some(Arc::new(handler));
-    }
-
     /// Attaches a handler for when a [`GuildCreate`] is received.
     ///
     /// [`GuildCreate`]: ../model/event/enum.Event.html#variant.GuildCreate
@@ -515,7 +487,7 @@ impl Client {
     /// ```rust,ignore
     /// use serenity::Client;
     ///
-    /// let mut client = Client::login_bot("bot token here");
+    /// let mut client = Client::login("bot token here");
     ///
     /// client.on_message(|_context, message| {
     ///     println!("{}", message.content);
@@ -640,7 +612,7 @@ impl Client {
     /// use std::env;
     ///
     /// let token = env::var("DISCORD_BOT_TOKEN").unwrap();
-    /// let mut client = Client::login_bot(&token);
+    /// let mut client = Client::login(&token);
     ///
     /// client.on_ready(|_context, ready| {
     ///     println!("{} is connected", ready.user.name);
@@ -676,26 +648,6 @@ impl Client {
             .on_channel_recipient_removal = Some(Arc::new(handler));
     }
 
-    /// Attaches a handler for when a [`RelationshipAdd`] is received.
-    ///
-    /// [`RelationshipAdd`]: ../model/event/enum.Event.html#variant.RelationshipAdd
-    pub fn on_relationship_add<F>(&mut self, handler: F)
-        where F: Fn(Context, Relationship) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_relationship_addition = Some(Arc::new(handler));
-    }
-
-    /// Attaches a handler for when a [`RelationshipRemove`] is received.
-    ///
-    /// [`RelationshipRemove`]: ../model/event/enum.Event.html#variant.RelationshipRemove
-    pub fn on_relationship_remove<F>(&mut self, handler: F)
-        where F: Fn(Context, UserId, RelationshipType) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_relationship_removal = Some(Arc::new(handler));
-    }
-
     /// Attaches a handler for when a [`Resumed`] is received.
     ///
     /// [`Resumed`]: ../model/event/enum.Event.html#variant.Resumed
@@ -785,7 +737,6 @@ impl Client {
 
             let boot = boot_shard(&BootInfo {
                 gateway_url: gateway_url.clone(),
-                login_type: self.login_type,
                 shard_info: shard_info,
                 token: self.token.clone(),
             });
@@ -806,13 +757,11 @@ impl Client {
                                  &shard,
                                  &self.framework,
                                  &self.data,
-                                 self.login_type,
                                  &self.event_store);
                     } else {
                         dispatch(Event::Ready(ready),
                                  &shard,
                                  &self.data,
-                                 self.login_type,
                                  &self.event_store);
                     }}
 
@@ -822,7 +771,6 @@ impl Client {
                             event_store: self.event_store.clone(),
                             framework: self.framework.clone(),
                             gateway_url: gateway_url.clone(),
-                            login_type: self.login_type,
                             receiver: receiver,
                             shard: shard,
                             shard_info: shard_info,
@@ -833,7 +781,6 @@ impl Client {
                             data: self.data.clone(),
                             event_store: self.event_store.clone(),
                             gateway_url: gateway_url.clone(),
-                            login_type: self.login_type,
                             receiver: receiver,
                             shard: shard,
                             shard_info: shard_info,
@@ -964,16 +911,6 @@ impl Client {
             .on_guild_role_update = Some(Arc::new(handler));
     }
 
-    /// Attaches a handler for when a [`UserGuildSettingsUpdate`] is received.
-    ///
-    /// [`UserGuildSettingsUpdate`]: ../model/event/enum.Event.html#variant.UserGuildSettingsUpdate
-    pub fn on_user_guild_settings_update<F>(&mut self, handler: F)
-        where F: Fn(Context, Option<UserGuildSettings>, UserGuildSettings) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_user_guild_settings_update = Some(Arc::new(handler));
-    }
-
     /// Attaches a handler for when a [`GuildUpdate`] is received.
     ///
     /// [`GuildUpdate`]: ../model/event/enum.Event.html#variant.GuildUpdate
@@ -984,31 +921,6 @@ impl Client {
             .on_guild_update = Some(Arc::new(handler));
     }
 
-    /// Attaches a handler for when a [`UserNoteUpdate`] is received.
-    ///
-    /// Optionally returns the old note for the [`User`], if one existed.
-    ///
-    /// [`User`]: ../model/struct.User.html
-    /// [`UserNoteUpdate`]: ../model/event/enum.Event.html#variant.UserNoteUpdate
-    pub fn on_note_update<F>(&mut self, handler: F)
-        where F: Fn(Context, UserId, Option<String>, String) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_note_update = Some(Arc::new(handler));
-    }
-
-    /// Attaches a handler for when a [`UserSettingsUpdate`] is received.
-    ///
-    /// The old user settings will be provided as well.
-    ///
-    /// [`UserSettingsUpdate`]: ../model/event/enum.Event.html#variant.UserSettingsUpdate
-    pub fn on_user_settings_update<F>(&mut self, handler: F)
-        where F: Fn(Context, UserSettings, UserSettings) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_user_settings_update = Some(Arc::new(handler));
-    }
-
     /// Attaches a handler for when a [`UserUpdate`] is received.
     ///
     /// The old current user will be provided as well.
@@ -1110,16 +1022,6 @@ impl Client {
             .on_guild_role_update = Some(Arc::new(handler));
     }
 
-    /// Attaches a handler for when a [`UserGuildSettingsUpdate`] is received.
-    ///
-    /// [`UserGuildSettingsUpdate`]: ../model/event/enum.Event.html#variant.UserGuildSettingsUpdate
-    pub fn on_user_guild_settings_update<F>(&mut self, handler: F)
-        where F: Fn(Context, UserGuildSettings) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_user_guild_settings_update = Some(Arc::new(handler));
-    }
-
     /// Attaches a handler for when a [`GuildUpdate`] is received.
     ///
     /// [`GuildUpdate`]: ../model/event/enum.Event.html#variant.GuildUpdate
@@ -1130,29 +1032,6 @@ impl Client {
             .on_guild_update = Some(Arc::new(handler));
     }
 
-    /// Attaches a handler for when a [`UserNoteUpdate`] is received.
-    ///
-    /// Optionally returns the old note for the [`User`], if one existed.
-    ///
-    /// [`User`]: ../model/struct.User.html
-    /// [`UserNoteUpdate`]: ../model/event/enum.Event.html#variant.UserNoteUpdate
-    pub fn on_note_update<F>(&mut self, handler: F)
-        where F: Fn(Context, UserId, String) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_note_update = Some(Arc::new(handler));
-    }
-
-    /// Attaches a handler for when a [`UserSettingsUpdate`] is received.
-    ///
-    /// [`UserSettingsUpdate`]: ../model/event/enum.Event.html#variant.UserSettingsUpdate
-    pub fn on_user_settings_update<F>(&mut self, handler: F)
-        where F: Fn(Context, UserSettingsUpdateEvent) + Send + Sync + 'static {
-        self.event_store.write()
-            .unwrap()
-            .on_user_settings_update = Some(Arc::new(handler));
-    }
-
     /// Attaches a handler for when a [`UserUpdate`] is received.
     ///
     /// [`UserUpdate`]: ../model/event/enum.Event.html#variant.UserUpdate
@@ -1166,7 +1045,6 @@ impl Client {
 
 struct BootInfo {
     gateway_url: Arc<Mutex<String>>,
-    login_type: LoginType,
     shard_info: Option<[u64; 2]>,
     token: String,
 }
@@ -1177,7 +1055,6 @@ struct MonitorInfo {
     event_store: Arc<RwLock<EventStore>>,
     framework: Arc<Mutex<Framework>>,
     gateway_url: Arc<Mutex<String>>,
-    login_type: LoginType,
     receiver: Receiver<WebSocketStream>,
     shard: Arc<Mutex<Shard>>,
     shard_info: Option<[u64; 2]>,
@@ -1189,7 +1066,6 @@ struct MonitorInfo {
     data: Arc<Mutex<ShareMap>>,
     event_store: Arc<RwLock<EventStore>>,
     gateway_url: Arc<Mutex<String>>,
-    login_type: LoginType,
     receiver: Receiver<WebSocketStream>,
     shard: Arc<Mutex<Shard>>,
     shard_info: Option<[u64; 2]>,
@@ -1220,8 +1096,7 @@ fn boot_shard(info: &BootInfo) -> Result<(Shard, ReadyEvent, Receiver<WebSocketS
 
         let attempt = Shard::new(&info.gateway_url.lock().unwrap(),
                                  &info.token,
-                                 info.shard_info,
-                                 info.login_type);
+                                 info.shard_info);
 
         match attempt {
             Ok((shard, ready, receiver)) => {
@@ -1253,7 +1128,6 @@ fn monitor_shard(mut info: MonitorInfo) {
         for _ in 0..3 {
             let boot = boot_shard(&BootInfo {
                 gateway_url: info.gateway_url.clone(),
-                login_type: info.login_type,
                 shard_info: info.shard_info,
                 token: info.token.clone(),
             });
@@ -1275,13 +1149,11 @@ fn monitor_shard(mut info: MonitorInfo) {
                                  &info.shard,
                                  &info.framework,
                                  &info.data,
-                                 info.login_type,
                                  &info.event_store);
                     } else {
                         dispatch(Event::Ready(ready),
                                  &info.shard,
                                  &info.data,
-                                 info.login_type,
                                  &info.event_store);
                     }}
 
@@ -1352,19 +1224,17 @@ fn handle_shard(info: &mut MonitorInfo) {
                      &info.shard,
                      &info.framework,
                      &info.data,
-                     info.login_type,
                      &info.event_store);
         } else {
             dispatch(event,
                      &info.shard,
                      &info.data,
-                     info.login_type,
                      &info.event_store);
         }}
     }
 }
 
-fn login(token: String, login_type: LoginType) -> Client {
+fn login(token: String) -> Client {
     rest::set_token(&token);
 
     feature_framework! {{
@@ -1372,14 +1242,12 @@ fn login(token: String, login_type: LoginType) -> Client {
             data: Arc::new(Mutex::new(ShareMap::custom())),
             event_store: Arc::new(RwLock::new(EventStore::default())),
             framework: Arc::new(Mutex::new(Framework::default())),
-            login_type: login_type,
             token: token,
         }
     } else {
         Client {
             data: Arc::new(Mutex::new(ShareMap::custom())),
             event_store: Arc::new(RwLock::new(EventStore::default())),
-            login_type: login_type,
             token: token,
         }
     }}
diff --git a/src/client/rest/mod.rs b/src/client/rest/mod.rs
index c341bf2..8757114 100644
--- a/src/client/rest/mod.rs
+++ b/src/client/rest/mod.rs
@@ -45,7 +45,7 @@ use std::default::Default;
 use std::fmt::Write as FmtWrite;
 use std::io::{ErrorKind as IoErrorKind, Read};
 use std::sync::{Arc, Mutex};
-use ::constants::{self, ErrorCode};
+use ::constants;
 use ::internal::prelude::*;
 use ::model::*;
 use ::utils::{decode_array, into_array};
@@ -82,24 +82,6 @@ pub fn set_token(token: &str) {
     TOKEN.lock().unwrap().clone_from(&token.to_owned());
 }
 
-/// Marks a [`Channel`] as being "read" up to a certain [`Message`]. Any
-/// message past the given one will not be marked as read.
-///
-/// Usually you should use this to mark the latest message as being read.
-///
-/// **Note**: Bot users should not use this, as it has no bearing on them
-/// whatsoever.
-///
-/// [`Channel`]: ../../model/enum.Channel.html
-/// [`Message`]: ../../model/struct.Message.html
-pub fn ack_message(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204, request!(Route::ChannelsIdMessagesIdAck(channel_id),
-                         post,
-                         "/channels/{}/messages/{}/ack",
-                         channel_id,
-                         message_id))
-}
-
 /// Adds a [`User`] as a recipient to a [`Group`].
 ///
 /// **Note**: Groups have a limit of 10 recipients, including the current user.
@@ -214,10 +196,9 @@ pub fn create_emoji(guild_id: u64, map: &Value) -> Result<Emoji> {
 /// Only a [`PartialGuild`] will be immediately returned, and a full [`Guild`]
 /// will be received over a [`Shard`], if at least one is running.
 ///
-/// **Note**: This endpoint is usually only available for user accounts. Refer
-/// to Discord's documentation for the endpoint [here][whitelist] for more
-/// information. If your bot requires this, re-think what you are doing and
-/// whether it _really_ needs to be doing this.
+/// **Note**: This endpoint is currently limited to 10 active guilds. The
+/// limits are raised for whitelisted [GameBridge] applications. See the
+/// [documentation on this endpoint] for more info.
 ///
 /// # Examples
 ///
@@ -241,7 +222,9 @@ pub fn create_emoji(guild_id: u64, map: &Value) -> Result<Emoji> {
 /// [`Guild`]: ../../model/struct.Guild.html
 /// [`PartialGuild`]: ../../model/struct.PartialGuild.html
 /// [`Shard`]: ../gateway/struct.Shard.html
+/// [GameBridge]: https://discordapp.com/developers/docs/topics/gamebridge
 /// [US West Region]: ../../model/enum.Region.html#variant.UsWest
+/// [documentation on this endpoint]: https://discordapp.com/developers/docs/resources/guild#create-guild
 /// [whitelist]: https://discordapp.com/developers/docs/resources/guild#create-guild
 pub fn create_guild(map: &Value) -> Result<PartialGuild> {
     let body = map.to_string();
@@ -517,8 +500,8 @@ pub fn delete_role(guild_id: u64, role_id: u64) -> Result<()> {
 /// use std::env;
 ///
 /// // Due to the `delete_webhook` function requiring you to authenticate, you
-/// // must have initialized a client first.
-/// let client = Client::login_user(&env::var("DISCORD_TOKEN").unwrap());
+/// // must have set the token first.
+/// rest::set_token(&env::var("DISCORD_TOKEN").unwrap());
 ///
 /// rest::delete_webhook(245037420704169985).expect("Error deleting webhook");
 /// ```
@@ -641,16 +624,6 @@ pub fn edit_nickname(guild_id: u64, new_nickname: Option<&str>) -> Result<()> {
     verify(200, response)
 }
 
-/// Changes a profile note.
-pub fn edit_note(user_id: u64, map: &Value) -> Result<()> {
-    let body = map.to_string();
-
-    verify(204, request!(Route::None,
-                         put(body),
-                         "/users/@me/notes/{}",
-                         user_id))
-}
-
 /// Edits the current user's profile settings.
 ///
 /// For bot users, the password is optional.
@@ -1271,14 +1244,6 @@ pub fn get_user(user_id: u64) -> Result<User> {
     User::decode(serde_json::from_reader(response)?)
 }
 
-/// Gets our connections.
-pub fn get_user_connections() -> Result<Vec<UserConnection>> {
-    let response = request!(Route::UsersMeConnections, get, "/users/@me/connections");
-
-    decode_array(serde_json::from_reader(response)?,
-                      UserConnection::decode)
-}
-
 /// Gets our DM channels.
 pub fn get_user_dm_channels() -> Result<Vec<PrivateChannel>> {
     let response = request!(Route::UsersMeChannels, get, "/users/@me/channels");
@@ -1380,67 +1345,6 @@ pub fn remove_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
                          user_id))
 }
 
-/// Searches a [`Channel`] for [`Message`]s that meet provided requirements.
-///
-/// **Note**: Bot users can not search.
-///
-/// [`Channel`]: ../../model/enum.Channel.html
-/// [`Message`]: ../../model/struct.Message.html
-pub fn search_channel_messages(channel_id: u64, map: BTreeMap<&str, Value>)
-    -> Result<SearchResult> {
-    let mut uri = format!("/channels/{}/messages/search?", channel_id);
-
-    for (k, v) in map {
-        let _ = write!(uri, "&{}={}", k, v);
-    }
-
-    let response = request!(Route::ChannelsIdMessagesSearch(channel_id),
-                            get,
-                            "{}",
-                            uri);
-
-    if response.status == StatusCode::Accepted {
-        return Err(Error::Client(ClientError::ErrorCode(ErrorCode::SearchIndexUnavailable)));
-    }
-
-    let content = try!(serde_json::from_reader(response));
-
-    SearchResult::decode(content)
-}
-
-/// Searches a [`Guild`] - and optionally specific [channel][`GuildChannel`]s
-/// within it - for messages that meet provided requirements.
-///
-/// **Note**: Bot users can not search.
-///
-/// [`Guild`]: ../../model/struct.Guild.html
-/// [`GuildChannel`]: ../../model/struct.GuildChannel.html
-pub fn search_guild_messages(guild_id: u64,
-                             channel_ids: &[u64],
-                             map: BTreeMap<&str, Value>)
-                             -> Result<SearchResult> {
-    let mut uri = format!("/guilds/{}/messages/search?", guild_id);
-
-    for (k, v) in map {
-        let _ = write!(uri, "&{}={}", k, v);
-    }
-
-    for channel_id in channel_ids {
-        write!(uri, "&channel_id={}", channel_id)?;
-    }
-
-    let response = request!(Route::GuildsIdMessagesSearch(guild_id),
-                            get,
-                            "{}",
-                            uri);
-
-    if response.status == StatusCode::Accepted {
-        return Err(Error::Client(ClientError::ErrorCode(ErrorCode::SearchIndexUnavailable)));
-    }
-
-    SearchResult::decode(try!(serde_json::from_reader(response)))
-}
-
 /// Sends a file to a channel.
 pub fn send_file<R: Read>(channel_id: u64,
                           mut file: R,
diff --git a/src/client/rest/ratelimiting.rs b/src/client/rest/ratelimiting.rs
index 00c374f..c8849eb 100644
--- a/src/client/rest/ratelimiting.rs
+++ b/src/client/rest/ratelimiting.rs
@@ -159,12 +159,6 @@ pub enum Route {
     ///
     /// [`ChannelId`]: ../../model/struct.ChannelId.html
     ChannelsIdMessagesIdReactionsUserIdType(u64),
-    /// Route for the `/channels/:channel_id/messages/search` path.
-    ///
-    /// The data is the relevant [`ChannelId`].
-    ///
-    /// [`ChannelId`]: ../../model/struct.ChannelId.html
-    ChannelsIdMessagesSearch(u64),
     /// Route for the `/channels/:channel_id/permissions/:target_id` path.
     ///
     /// The data is the relevant [`ChannelId`].
@@ -292,12 +286,6 @@ pub enum Route {
     ///
     /// [`GuildId`]: struct.GuildId.html
     GuildsIdMembersMeNick(u64),
-    /// Route for the `/guilds/:guild_id/messages/search` path.
-    ///
-    /// The data is the relevant [`GuildId`].
-    ///
-    /// [`GuildId`]: struct.GuildId.html
-    GuildsIdMessagesSearch(u64),
     /// Route for the `/guilds/:guild_id/prune` path.
     ///
     /// The data is the relevant [`GuildId`].
@@ -336,8 +324,6 @@ pub enum Route {
     UsersMe,
     /// Route for the `/users/@me/channels` path.
     UsersMeChannels,
-    /// Route for the `/users/@me/connections` path.
-    UsersMeConnections,
     /// Route for the `/users/@me/guilds` path.
     UsersMeGuilds,
     /// Route for the `/users/@me/guilds/:guild_id` path.